简述各种内部类

内部类的分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

内部类：在一个类的内部再定义一个完整的类，编译之后可生成独立的字节码文件，
内部类可直接访问外部类的私有成员，而不破坏封装性，可为外部类提供必要的内部功能组件。

class Outer {
	class Inner {
	}
}

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

public class Outer {
	private String name = "张三";
	private int age = 20;
	
	//内部类,前面也可以加入修饰符
	class Inner{
		private String address = "北京";
		private String phone = "110";
		private String name = "李四";
		//方法
		public void show() {
			//打印外部类属性
			System.out.println(Outer.this.name); //张三
			System.out.println(age);  //20
			//打印内部类属性
			System.out.println(address); //北京
			System.out.println(phone); //110
			System.out.println(name);  //李四
			
		}
	}
}

对于内部类的创建，可以采用线创建外部类，再创建内部类

Outer out = new Outer();
Inner inner = out.new Inner();

也可以直接创建内部类

Inner inner = new Outer().new Inner();

当外部类与内部类存在重名属性时，会优先访问内部类属性。如果要访问外部类的重名属性，可以使用：外部类名+this+重名属性名；比如上面例子中的name变量

//这样会使你的调用更加的明确
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//打印内部类属性
System.out.println(this.address);
System.out.println(this.phone);
System.out.println(this.name);

成员内部类不能定义静态成员，但可以有静态常量

静态内部类

不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员（相当于外部类）
只有内部类才可以是静态的，普通的类不可以用static修饰

public class Outer {
	private String name = "张三";
	private int age = 20;
	
	//静态内部类，他的级别和外部类相同，目的是为了给外部类提供一些功能
	static class Inner{
		private String address = "北京";
		private String phone = "110";
		//可以包含静态成员
		private static int count = 1000;
		
		//方法
		public void show() {
			//调用外部类的属性
			//先创建外部类对象
			Outer outer = new Outer();
			//再来调用外部类对象的属性
			System.out.println(outer.name);
			System.out.println(outer.age);
			
			//调用静态内部类的属性和方法
			System.out.println(address);
			System.out.println(phone);
			//调用静态内部类的静态属性
			System.out.println(Inner.count);
		}
	}
}

静态内部类的创建

//静态内部类相当于外部类，所以可以直接创建静态内部类
Outer.Inner inner = new Outer.Inner();
//Outer后面没有()只是代表一种包含关系，没有创建Outer对象
//Outer.Inner 一种包含关系

Inner inner = new Inner();
//也可以直接创建静态内部类

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final（jdk1.8后会自动添加）
局部内部类的使用范围是有限的，只能在当前方法中使用

public class Outer {
	private String name = "张三";
	private int age = 20;
	
	//如果此方法是静态的，那方法里的就不能直接访问非静态属性
	public  void show() {
		//定义局部变量
		String address = "北京";
		//System.out.println(new Outer().name);  // 如果是静态方法要这样引用类中的属性
		//局部内部类前面不能加任何访问修饰符，类似于局部变量，局部变量也不能加任何访问修饰符
		//局部内部类中也不可以使用静态变量，但是可以使用静态常量
		class Inner {
			private String phone = "155";
			private String email = "liu@qq.com";
			
			//局部内部类的方法
			public void showInner() {
				//访问外部类的属性
				System.out.println(name); //直接访问外部类属性
				System.out.println(Outer.this.name);
				System.out.println(age);
				//访问内部类的属性
				System.out.println(phone);
				System.out.println(email);
				//访问局部变量,jdk1.7要求，变量必须是常量final，jdk1.8自动添加final
				//所以后面就不能对局部变量进行修改
				System.out.println(address); //此时已经不是引用变量了，是一个实际的常量
			}
		}
		//要想使用局部内部类中方法，要在方法中创建局部内部类对象
		Inner inner = new Inner();
		inner.showInner();
	}
	
}

方法中的局部变量，在方法执行完毕后，局部变量就销毁了，但是创建的new Inner()对象还在，只是这个对象的引用变量销毁了，所以为了生命周期相同，所有类中的方法不能引用局部变量，可以引用常量

匿名内部类

没有类名的局部内部类（一切特征都与局部内部类相同）
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
定义一个接口：

//定义一个接口
public interface Usb{
	void service();
}

创建一个接口实现类

public class Mouse implements Usb {
		@Override
	public void sevice() {
		System.out.println("鼠标开始工作");
		
	}
}

创建对象

public class Test {
	public static void main(String[] args) {
		//创建接口类型的变量
		Usb usb = new Mouse();
		usb.sevice();
  ｝
｝

上面就是定义类、实现类、创建对象的过程，可以使用局部内部类的方式来使用这个接口

public class Test {
	public static void main(String[] args) {

		使用局部内部类写（在静态的main方法中写一个类）
		class Fan implements Usb{

	@Override
	public void sevice() {
		System.out.println("风扇开始工作");
		
	}
			
		}
		
		//使用局部内部类创建对象
		Usb usb = new Fan();
		usb.sevice();
		
｝｝

上面使用局部类的方式实现了接口，如果多个类都实现这个接口就要写多个类，比较麻烦，所有采用匿名内部类

public class Test {
	public static void main(String[] args) {
	
		//使用匿名内部类（因为比如想上面的风扇类就使用了一次）
		//相当于创建了一个局部内部类
		Usb usb1 = new Usb(){
			@Override
			public void sevice() {
				System.out.println("风扇开始工作");
			}	
		};
		
		usb1.sevice();
	}
}	
//匿名内部类一个没有名字的内部类

当然还可以使用Lambda表达式对匿名内部类进行简化。