Java内部类

内部类

通常情况

一个 Java 文件中只有一个主类，也就意味着下面这样是错误的：

// 编译器会报错，一个 java 文件中只能有一个被 public 修饰的类，并且该类的类名与 java 文件名一致(Outer.java)
public class Outer{
}
public class Other{
}

将第二个类的 public 权限修饰符删除，就可以在 java 文件中定义多个类
并且每个类都可以被访问到

内部类的结构

内部类，顾名思义，就是 java 一个类中定义另一个类，如下所示：

public class Outer{
	class Inter{
	}
}

创建内部类

内部类在实例化的时候偷偷保留了指向外部类的引用。因此在创建内部类对象的同时，必须先创建外部类对象（静态内部类除外）

• 通过外部类中的方法得到内部类

public class Outer{
	public Inter inter() {
		return new Inter();
	}
	class Inter{
	}
	public static void main(String[] args) {
		Outer outer = new Outer();
		Inter inter = outer.inter();
	}
}

• 内部类对象通过 外部类对象的 .new 方法创建

public class Outer{
	class Inter{
	}
	public static void main(String[] args) {
		// 通俗易懂的创建方式
		Outer outer = new Outer();
		Outer.Inter inter0 = outer.new Inter();
		// 一次创建完毕
		Inter inter1 = new Outer().new Inter();
		Outer.Inter inter2 = new Outer().new Inter();
	}
}

内部类对象通过 外部类.this 方法得到父类

public class Outer{
	class Inter{
		Outer getOuter() {
			return Outer.this;
		}
	}
	public static void main(String[] args) {
		Outer outer1 = new Outer();
		Outer.Inter inter = outer1.new Inter();
		Outer outer2 = inter.getOuter();
		// 两个对象是同一个
		System.out.println(outer1 == outer2);	// true
	}
}

内部类的特点

内部类默认可以访问外部类中所有的成员

public class Outer{
	Object[] items = new Object[2];
	private int index = 0;
	class Inter{
		public void add(String s) {
			// 在Inter类中，可以访问到外部的private成员变量
			if (index<items.length) items[index++]=s;; 
		}
	}
	public static void main(String[] args) {
		Outer outer = new Outer();
		Outer.Inter inter = outer.new Inter();
		inter.add("元素一");
		inter.add("元素二");
		System.out.println(outer.items[1]);	// print:元素二
	}
}

内部类与向上转型

将内部类声明为private或者protected。同时，在创建内部类实例对象的时候，通过内部类的父接口来声明对象变量，这样一来，客户端程序员就只能访问接口中定义的公共方法。因而实现了对接口实现过程代码的隐藏。

public class Outer{
	public Inter inter() {
		return new Inter();
	}
	interface People{
		void speak();
	}
	class Inter implements People{
		public void speak() {
			System.out.println("这是接口中的一个方法");
		}
		public void sleep(){
		}
	}
	public static void main(String[] args) {
		// 程序员无法访问到内部类实现的接口以外的方法
		Outer outer = new Outer();
		People inter = outer.inter();
		inter.speak();
		// inter.sleep()	访问不到
	}
}

在方法中和作用域内的内部类

内部类可以在方法里面或者在任意的作用域中定义内部类。

匿名内部类

看起来就像创建类对象的时候，同时在这里插入该类的定义。

用的比较多的： new 接口(){ 接口的实现 }，这样就不用再定义具体的一个实现类了

public class Outer{
    // 接口
	interface Inter{
		void speak();
	}
	public Inter inter() {
        // 返回的时候，将接口实现
		return new Inter(){
			public void speak() {
				System.out.println("hello");
			}
		};
	}
}

嵌套类（静态内部类）

使用 static 修饰的内部类就是嵌套类了。内部类不依赖于外部类对象，没有 .this方法，普通内部类中不能有static方法或成员和嵌套类。而嵌套类里边可以有static方法和成员，也可以继续嵌套一个类

public class Outer{
	static class Inter{
		static String des = "静态成员变量";
		static void speak() {
			System.out.println("静态方法");
		}
		static class InterInter{
			static {
				String des = "嵌套类中的嵌套类";
			}
		}
	}
	public static void main(String[] args) {
		Inter.speak();
	}
}

• 接口内部的嵌套类
  接口中的类都会被声明为public，static。可以通过在接口内部写一个嵌套类，并且在这个嵌套类中创建公共代码

每个类中测试的时候都需要主方法，但是你可以在一个嵌套类中定义一个main方法，这样外部类在解析这个嵌套类的时候会执行其中的静态main方法，从而外部类不用特意写个主方法了

• 无论嵌套多少层都没事，嵌套类总能访问外部类的成员（无论其访问修饰符是什么），最里层的嵌套类可以访问外层的所有成员

为什么使用内部类

每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否及经济成了某个（接口的）实现，对于内部类都没有影响

• 可以解决多重继承问题
• （闭包与回调）通过内部类提供闭包的功能是优良的解决方案，他比指针更灵活、更安全。

闭包(closure)是一个可调用的对象，他记录了一些信息，这些信息来自创建它的作用域。

• 内部类和控制框架
  每个内部类都可以独立地实现一个action
  内部类可以很容易访问外围类的任意成员