19.Java之内部类（内部类的基本介绍，内部类的分类，局部内部类的使用，匿名内部类的使用，成员内部类的使用，静态内部类的使用）

19.1.基本介绍

一个类的内部又完整的嵌套了另一个类的结构。被嵌套的类称为内部类，嵌套其他类的类称为外部类，是类的第五大成员。

类的五大成员：属性、方法、构造器、代码块、内部类

内部类最大的特点：就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

19.2.基本语法

class Outer{  //外部类
	class Inner{ //内部类
	}
}
class Other{ //外部其它类
}

19.3.内部类的分类

• 定义在外部类局部位置上（比如方法内）：

1. 局部内部类（有类名）
2. 匿名内部类（没有类名）

• 定义在外部类的成员位置上：

1. 成员内部类（没用static修饰）
2. 静态内部类（使用static修饰）

19.4.局部内部类的使用

局部内部类是定义在外部类的局部位置，方法或者代码块中，并且有类名，本质是个类

1. 可以直接访问外部类的所有成员，包含私有的
2. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的，但是可以使用 final 修饰，因为局部变量也可以使用 final
3. 作用域：仅仅在定义它的方法或代码块中
4. 局部内部类----访问---->外部类的成员 [访问方式：直接访问]
5. 外部类----访问---->局部内部类的成员 [访问方式：创建对象，再访问（注意：必须在作用域中）]
6. 外部其他类----不能访问---->局部内部类（因为 局部内部类地位是一个局部变量）
7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

19.5.匿名内部类的使用

1.本质是类 2.内部类 3.该类没有名字 4.同时还是一个对象

匿名内部类的基本语法

new 类或接口(参数列表){
	类体
};

例子：
(1) 需要：想使用IA接口，并创建对象
(2) 传统方式，是写一个类，实现该接口，并创建对象
(3) 对于类只使用一次，后面不再使用的话，可以用匿名内部类来简化开发

• 接口

interface IA {
	void cry();
}

• 匿名内部类

IA tiger = new IA() {
	@Override
	public void cry() {
		System.out.println("老虎叫唤...");
	}
};
tiger.cry();//动态绑定

jdk底层在创建匿名内部类 ，立即马上就创建了该实例，并且把地址返回给 tiger
匿名内部类使用一次，就不能再使用（是该匿名内部类找不到了，但是对象还在）

• 匿名内部类底层实际会分配类名，假设该外部类的类名为Outer04，那么匿名内部类被分配的类名为 Outer04$1

class Outer04$1 implements IA {
	@Override
	public void cry() {
		System.out.println("老虎叫唤...");
	}
}

1. 匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法

//定义类的特征
IA tiger = new IA() {
	@Override
	public void cry() {
		System.out.println("老虎叫唤...");
	}
};
tiger.cry();

//创建对象的特征
new IA() {
	@Override
	public void cry() {
		System.out.println("老虎叫唤...");
	}
}.cry();

2. 可以直接访问外部类的所有成员，包含私有的
3. 不能添加访问修饰符，因为它的地位就是一个局部变量
4. 作用域：仅仅在定义它的方法或代码块中
5. 匿名内部类----访问---->外部类成员 [访问方式：直接访问]
6. 外部其他类----不能访问---->匿名内部类（因为匿名内部类地位是一个局部变量）
7. 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去访问

19.6.成员内部类的使用

成员内部类是定义在外部类的成员位置，并且没有 static 修饰

1. 可以直接访问外部类的所有成员，包含私有的
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
3. 作用域：和外部类的其他成员一样，为整个类体
4. 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去访问
5. 成员内部类----访问---->外部类 [访问方式：直接访问]
6. 外部类 ----访问---->成员内部类 [访问方式：创建对象，再访问]
7. 外部其他类----访问---->成员内部类
   两种方式：

class Outer{
	class Innter{
		public void say(){
			System.out.println("这是成员内部类");
		}
	}
	public Innter getInnterInstance(){
		return new Innter();
	}
}

第一种：Outer outer01 = new Outer(); Outer.Innter innter = outer01.new Innter();
第二种：Outer.Innter innter = new Outer().getInnterInstance();

19.7.静态内部类的使用

静态内部类是定义在外部类的成员变量，并且有 static 修饰

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
3. 作用域：同其他的成员，为整个类体
4. 静态内部类----访问---->外部类（比如：静态属性） [访问方式：直接访问所有静态成员]
5. 外部类----访问---->静态内部类 [访问方式：创建对象，再访问]
6. 外部其他类----访问---->静态内部类
   方式1：Outer.Innter innter = new Outer().Inner();
   方式2：Outer.Innter innter = Outer.getInnterInstance();