(成员)内部类-常用
特点：可以把内部类当作是外部类的一个【成员】
- 同外部类的成员一样，内部类可被private、protected等权限修饰符修饰
- 同外部类的成员一样，private修饰的内部类仅对外部类是可见的【public Inner in=new Inner();】，对外部类以外的地方不可见
- 同外部类的成员一样，内部类中也可以访问外部类的private成员（当然包括static成员）
- 同外部类的成员不一样的是，成员内部类中不能定义静态变量(否则就要定义为静态内部类)，但是可以定义 static final 变量(即常量)
- 同外部类的成员不一样的是，编译完成后，内部类会被编译成一个独立的类【Outer$Inner.class】，而不是Outer类的一个域
特殊使用场合：
通过使用内部类可以间接实现多继承，可以解决实现的多个接口之间，或继承的类与接口之间方法同名的冲突
例如 class Robot extends People implement Machine { }
而若 class People 和 interface Machine 都有一个同名的方法 run()
此时若按以上结构是无法区分 Robot 中的 run() 到底是继承的还是实现的
此时的解决方式为：让 Robot 仅继承或仅实现，再在 Robot 中定义一个内部类仅实现或仅继承即可
外部类访问内部类的方式：
- 1.1、在外部类及其[非静态]方法中可以直接访问内部类【 new Inner().内部类的成员】
- 1.2、在外部类的[静态]方法中需要先创建外部类对象，才访问内部类【new Outer(). new Inner().内部类的成员】
- 1.3、其他地方访问内部类也是【new Outer(). new Inner().内部类的成员】
内部类访问外部类的方式：
- 2.1、外部类的成员变量如果和内部类的变量不同名，则内部类可直接用【变量名】访问外部类的成员变量
- 2.2、若同名，则内部类可用【Outer.this.变量名】来访问外部类的实例变量(注意不是Outer.Inner.变量名)
- 2.3、在内部类中直接用【变量名】或【this.变量名】访问的都是内部类自己的实例变量
// 外部类之外的其他类
class InnerClassDemo {
public static void main(String[] args) {
new Outer().new Inner().innerSpeak(); //1.3、其他地方访问内部类
}
}
//外部类
class Outer {
private static int age = 1;
private String name = "外部类";
private Inner ooo = new Inner(); //1.1、在外部类中可以直接访问内部类
public void method() {
new Inner().innerSpeak(); //1.1、在外部类的非静态方法中可以直接访问内部类
}
public static void method2() {
new Outer().new Inner().innerSpeak();//1.2、在外部类的静态方法中访问内部类
}
//内部类
class Inner {
private String name = "普通内部类";
void innerSpeak() {
System.out.println(age++ + "..." + name); //2.1、不同名，可直接用变量名访问外部类的成员变量
}
void hello() {
String name = "局部变量";
System.out.println(Outer.this.name + "..." + this.name + "..." + name); //2.2、同名，可用Outer.this.变量名 访问
}
}
}
静态内部类-较麻烦
特点：可以把静态内部类当作外部类的一个【静态成员】
- 和静态成员一样，静态内部类用 static 定义，可以用 public,protected,private修饰
- 和静态成员一样，静态内部类随着外部类的加载而产生，可以用外部类类名+静态成员名直接获得
- 和静态方法不一样的是，静态内部类中可以定义静态的也可以定义非静态的成员
外部类访问内部类方式：
- 1.1、外部类可以直接访问静态内部类【 new Inner().静态内部类的成员】
- 1.2、外部类的[静态和非静态]成员都可以用【Outer.Inner.成员】访问内部类的[静态]成员
- 1.3、外部类的[静态和非静态]成员都可以用【new Outer.Inner().成员】访问内部类的[非静态]成员
- 1.4、其他地方访问内部类可用【new Outer.Inner().成员】，其中访问静态成员还可以用【Outer.Inner.成员】
内部类访问外部类方式：
- 2.1、若内部类的[静态和非静态]成员和外部类的[静态]成员不同名，可以直接用【成员名】访问
- 2.2、同名时，内部类的[静态和非静态]成员可以用【Outer.成员】访问外部类的[静态]成员
- 2.3、内部类的[静态和非静态]成员可以用【new Outer().成员】访问外部类的[非静态]成员
// 外部类之外的其他类
class InnerClassDemo {
public static void main(String[] args) {
new Outer.Inner2().innerSpeak(); //1.4
new Outer.Inner2().innerSpeak2(); //1.4
Outer.Inner2.innerSpeak(); //1.4
}
}
//外部类
class Outer {
private static int age = 1;
private String name = "外部类";
private Inner2 ooo = new Inner2(); //1.1
public void method() {
new Inner2().innerSpeak();//1.1
new Outer.Inner2().innerSpeak(); //1.1
Outer.Inner2.innerSpeak();//1.2
new Outer.Inner2().innerSpeak2(); //1.3
}
//静态内部类
static class Inner2 {
private static String name = "静态内部类";
static void innerSpeak() {
System.out.println(age + "..." + Outer.age + "..." + name + "..." + new Outer().name);//2.1、2.2、2.3
}
void innerSpeak2() {
System.out.println("静态内部类的非静态方法");
}
}
}
匿名内部类-最简单
典型使用场景：
- 若一个类继承于某个类(不般是一个抽象类)，或是实现了某个接口，那么此类一般是需要重写或实现某些抽象方法的
- 除此之外，若此类并不需要增加额外的成员，且我们不需要知道此类的实际类型(只是为了获得一个对象，且用完之后没有任何一个地方会再用到)，则适合使用匿名内部类
注意：
- 匿名内部类是唯一一种【无构造方法类】，匿名内部类中不能定义构造方法
- 匿名内部类在编译的时候由系统自动起名Out$1.class
常用格式一（单一引用）：
new Fu() { //或接口
void show(){} //子类【重写或隐藏】的父类的方法
}.show();
常用格式二（多引用）：
Fu f = new Fu() {
void show1(){}
void show2(){}
};
f.show1();
f.show2();
常用格式三（参数传递）：
obj.show(new InterfaceDemo(){ //函数参数是接口类型
public void show1(){} //接口中的方法通常不超过2个
public void show2(){}
});
局部内部类-不常用
特点：可以把局部内部类当作外部类方法中的一个局部变量
- 与局部变量一样，局部内部类是在方法(当然可以是静态方法)中定义的
- 与局部变量一样，局部内部类只能在其所在方法中使用，且不能被public、static等修饰
- 与局部变量一样，只有定义局部内部类之后的代码，才可访问局部内部类(即先定义后使用)
- 与局部变量一样，局部内部类可以访问外部类的任何成员
- 与局部变量不一样的是，局部内部类中不可定义静态变量(不管外部方法是不是静态的)
- 与局部变量不一样的是，局部内部类只能访问 final 修饰的局部变量(也即只能访问常量)
外部类不能访问局部内部类
内部类访问外部类的方式：
- 1.1、局部内部类的变量若和外部类的成员变量不同名，则可直接用【变量名】访问外部类的成员
- 1.2、若同名，则局部内部类可用【Outer.this.变量名】来访问外部类的成员
- 1.3、在局部内部类中可以直接用【变量名】或【this.变量名】来访问内部类自己的成员
// 外部类之外的其他类
class InnerClassDemo {
public static void main(String[] args) {
new Outer().method(3);
}
}
// 外部类
class Outer {
private int s = 1;
private static int o = 2;
private static int oo = 3;
public void method(final int k) {
final int s = 100;
final int oo = 200;
int i = 300;
//局部内部类
class Inner {
Inner(int k) {
method();//我是外部类的方法
System.out.println(o);//2
System.out.println(oo);//200
System.out.println(s);//100
System.out.println(Outer.this.s);//1
//System.out.println(i);//错误
}
}
new Inner(k);
}
private void method() {
System.out.println("我是外部类的方法");
}
}