内部类
如果一个事物的内部包含另外一个事物,那么这就是一个类内部包含另一个类
例如：身体和心脏的关系，又如汽车和发动机的关系
成员内部类
格式：
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//...
}
//...
}
注意：
内用外，随意访问,外用内,需要借助内部类对象
外部类的文件名是 内部类$内部类
使用成员内部类的俩个方法:
1.在外部类的方法当中，使用内部类;然后main只是调用外部类的方法。
2.直接方式,公式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
public class Body{ //外部类
public class Heart{ //成员内部类
//内部类的方法
public void beat(){
System.out.println("心脏跳动");
System.out.println("我叫" + name); //正确写法
}
}
//外部类的成员变量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private String name;
//外部类的方法
public void methodBody(){
System.out.println("外部类的方法");
Heart heart = new Heart();
heart.beat();
}
}
public class InnerClass {
public static void main(String[] args) {
Body body = new Body();
//通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
body.methodBody();
System.out.println("========================");
Body.Heart heart = new Body().new Heart();
}
}
内部类的同名变量访问：
- 如果出现了重名现象，那么格式是：外部类.this.成员变量名。
- 内部类可以直接访问外部类的成员,包括私有
- 外部类要访问内部类的成员,必须创建对象
public class Outer {
int num = 10;//外部类的成员变量
public class Inner{
int num = 20;//内部类的成员变量
public void methodInn(){
int num = 30; //内部类方法的局部变量
System.out.println(num);//局部变量，就近原则
System.out.println(this.num);//内部类的成员变量
System.out.println(Outer.this.num);//外部类的成员变量
}
}
}
public class InnerClass {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.methodInn();
}
}
注意事项：
- 私有内部类,只能在外部类中使用
- 静态内部类创建格式：外部类.内部类 对象名 = new 外部类.内部类()
- 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
局部内部类
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。 “局部”:只是当前所属的方法才能使用它，出了这个方法外面就不能用了。该类可以直接访问外部类的成员,也可以访问方法内的局部变量
格式
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class 局部内部类名称{
//...
}
}
}
定义一个类的时候，权限修饰符规则：
1.外部类：public / (default)
2.成员内部类： public / protected / (default) / private
3.局部内部类：什么都不能写
局部内部类的final问题：
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
匿名内部类【重点】
概述
匿名内部类本质上是一个特殊的局部内部类(定义在方法内部),
前提条件
需要存在一个接口或类
格式
new 类名或者接口名(){
重写方法;
}
public interface MyInterface {
void method(); //抽象方法
}
public class MyInterfaceImpl implements MyInterface {
@Override
public void method() {
System.out.println("实现类覆盖重写了方法！");
}
}
public class TestMain {
public static void main(String[] args) {
// MyInterface obj = new MyInterfaceImpl();
// obj.method();
//使用匿名内部类，但不是匿名对象，对象名就叫obj
MyInterface obj = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法！");
}
};
obj.method();
//使用匿名内部类，而且省略了对象名称，也是匿名对象
System.out.println("===============================");
new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类实现了方法！");
}
}.method();
}
}
理解
匿名内部类的理解：将继承\实现,方法重写,创建对象,放在了一步进行。
注意事项
1.对格式“new 接口名称(){....}”进行解析
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{...}这才是匿名内部类的内容
2.匿名内部类，在【创建对象的时候】，只能使用唯一一次。
3.如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了
4.匿名对象，在【调用方法】的时候，只能调用唯一一次，如果希望同一个对象，调用多次方法，那么必须给对象取个名字。
5.匿名内部类是省略了【实现类/子类的名称】,但是匿名对象是省略了【对象名称】。
发表于 2021-7-13 20:47
|
发表于 2021-7-13 22:06
共同加油
