内部类

定义

• 将一个类的定义放在另一个类的定义内部，就是内部类。

基本特点

• 一种代码隐藏机制，隐藏实现细节。内部类——某个接口的实现——能够完全不可见，并且不可用（修饰符private或protected）。
• 内部类自动拥有对其外围类所有成员的访问权。（内部类自动获取外围类对象的引用，通过该引用获取外围类成员）
• 内部类的对象只能在与其外围类的对象相关联（引用）的情况下才能被创建（在内部类是非static类时）。要想直接创建内部类对象，必须使用外部类的对象来创建该内部类对象。

interface Selector {
	boolean end();
	Object current();
	void next();
}
class Sequence {
	private Object[] items;
	private int next = 0;
	public Sequence(int size) { items = new Object[size]; } 
	public void add(Object x) {
		if (next < items.length - 1) 
			items[next++] = x;
	}
	private class SequenceSelector implents Selector {
		private int i = 0;
		public boolean end() { return i == items.length - 1; }
		public Object current() { return items[i]; }
		public void next() { if(i < items.length) i++; }
	}
	public Selector selector() {
		return new SequenceSelector();
	}
}

public class Test {
	public static void main(String[] args) {
		Sequence sequence = new Sequence();
		for (int i  = 0; i < 10; i++) 
			sequence.add(Integer.toString(i));
			Selector selector = sequence.selector();
			while(!selector.end()) {
				System.out.println(selector.current() + " ");
				selector.next();
			}
		// Illegal -- can`t access private class:
		//! Sequence.SequenceSelector ss = sequence.new SequenceSelector();
	} 
}

• 使用.this获取外部类对象的引用

public class DotThis {
	void show() { System.out.println("DotThis.show()"); }
	public class Inner{
		public DotThis getOuter() {
			return DotThis.this;
			// A plain "this" would be Inner`s "this"
		}
	}
	public Inner getInner(){ return new Inner(); }
	public static void main(String[] args) {
		DotThis dt = new DotThis();
		DotThis.Inner dti = dt.getInner();
		dti.getOuter().show();
	}
}
/* *Output:
 * DotThis.show()
 * /

• 使用.new在其他类对象中声明一个对象的内部类对象。注意不必声明（实际不能声明）dn.new DotNew.Inner();

public class DotNew{
	public class Inner{}
	public static void main(String[] args) {
		DotNew dn = new DotNew();
		DotNew.Inner dni = dn.new Inner();
		// You can not say 
		// ! DotNew.Inner dni = dn.new DotNew.Inner();
	}
}

• 同一子目录下的任意类中对某个内部类使用其它任意类中的某个内部类的类标识符，不会有命名冲突（包下不同类的内部类可以同名）。
• 内部类也必须生成一个.class文件以包含它们的Class对象信息。这些文件的命名有严格的规则：外围类的名字，加上"$"，再加上内部类的名字。如果内部类是匿名的，编译器会简单地产生一个数字作为其标识符。如果内部类是嵌套在别的内部类之中，只需要直接将它们的名字加在其外围标识符与"$"的后面。
• 从多层嵌套类中访问外部类成员。一个内部类被嵌套多少层并不重要——它能透明地访问所有它所嵌入的外部类的所有成员（不需要任何特殊条件）。

局部内部类(在方法和作用域内的内部类)

• 一个定义在方法中的内部类，在方法之外不能访问该类。
• 一个定义在作用域内的类，此作用域在方法的内部，在定义该类的作用域之外它是不可用的；除此之外，它与普通类一样。
• 局部内部类不能有访问说明符，因为它不是外围类的一部分；但是它可以访问当前代码块内的常量，以及此外围类的所有成员。

匿名内部类

• 一个实现了接口的匿名类（在这个匿名内部类中，使用来了默认的构造器生成Contents，*分号是必须的，return语句的结束符）

public interface Contents {
	int value();
}

public class Example {
	public Contents contents(){
		return new Contents() {
			private int i = 11;
			@Override
			public int value() { return i; }
		}; // Semicolon required in this case
	}
	public static void main(String[] args) {
		Example e = new Example();
		Contents c = e.contents();
	}
}
// 上述匿名内部类的语法是下述形式的简化形式
public class Example{
	class MyContents implements Contents {
		private int i = 11;
		@Override
		public int value() { return i; }
	}
	public Contents contents() {
		return new MyContents();
	}
	public static void main(String[] args) {
		Example e = new Example();
		Contents c = e.contents();
	}
}

• 一个匿名类，它扩展了有非默认构造器的内部，只需要简单地传递合适的参数给基类的构造器即可（不要求变量x一定是final的，因为x被传递给匿名类的基类构造器，它并不会再匿名类内部被直接使用）

public class Contents {
	private int i;
	public Contents(int i) { this.i = i; }
	public int value() { return i; };
}

public class Example {
	public Contents contents(int x){
		return new Contents(x) {
			@Override
			public int value() { return super.value() * 47; }
		}; // Semicolon required in this case
	}
	public static void main(String[] args) {
		Example e = new Example();
		Contents c = e.contents(9);
	}
}
// 上述匿名内部类的语法是下述形式的简化形式
public class Example{
	class MyContents extends Contents {
		@Override
		public int value() { return super.value() * 47;  }
	}
	public Contents contents(int x) {
		return new MyContents(x);
	}
	public static void main(String[] args) {
		Example e = new Example();
		Contents c = e.contents(9);
	}
}

• 一个匿名内部类，它执行字段初始化。（如果定义一个内部类，并且希望它（直接）使用一个在其外部定义的对象，那么编译器其参数引用是final的）

public interface Destination {
	String readLabel();
}

public class Example {
	// Argument must be final to use inside
	// anonymous inner class:
	public Destination destination(final String dest) {
		return new Destination() {
			private String label = dest;
			@Override
			public String readLabel() { return label; }
		}; // Semicolon required in this case
	}
	public static void main(String[] args) {
		Example e = new Example();
		Destination d = e.destination("Argument must be final");
	}
}

• 一个匿名类，它通过实例初始化实现构造(匿名类不可能有构造器——因为它根本没有名字)。（不要求变量i一定是final的，因为i被传递给匿名类的基类构造器，它并不会再匿名类内部被直接使用）

abstract class Base {
	public Base(int i) {
		System.out.println("Base constructor, i = " + i);
		public abstract void f();
	}
}
public class AnonymousConstructor {
	public static Base getBase(int i) {
		return new Base(i) {
			{ System.out.println("Inside instance initializer"); } // 实例初始化实现构造
			@Override
			public void f() {
				System.out.println("In anonymous f()");
			}
		}
	}
	public static void main(String[] args) {
		Base base = getBase(47);
		base.f();
	}
}
/* *Output:
 * Base constructor, i = 47
 * Inside instance initializer
 * In anonymous f()
*/

• 对于匿名类而言，实例初始化的实际效果就是构造器，不能重载实例初始化方法，所以你仅有一个这样的构造器。
• 匿名内部类与正规的继承相比有些受限，因为匿名内部类可以扩展类，也可以实现接口，但是不能两者兼备。而且如果是实现接口，也只能实现一个接口。
• 匿名内部类末尾的分号，并不是用来标记此内部类结束的。实际上，它标记的是表达式的结束，只不过这个表达式正巧包含了匿名内部类罢了。

嵌套类（内部类声明为static）

• 要创建嵌套类的对象，并不需要其外围类的对象。

public class Example {
	private static class ParcelContents implements Contents {
		private int i = 11;
		@Override
		public int value() { return i; }
	}
	public static Contents contents() {
		return new ParcelContents();
	}
	protected static class ParcelDestination implements Destination {
		private String label;
		private ParcelDestination(String whereTo) {
			label =whereTo;
		}
		@Override
		public String readLabel() { return label; }
		// Nested classes can contain other static elements:
		public static void f();
		static int x = 9;
		static class AnotherLevel() {
			public static void f() {}
			static int x = 9;
		}
	}
	public static Destination destination(String s) {
		return new ParcelDestination();
	}

	public static void main(String) {
		Contents c = contents();
		Destination d = destination("外围类对象对于我来说不是必需的");
	}
}

使用选取static成员的普通语法来调用方法——这些方法返回对static内部类的引用。

• 不能从嵌套类的对象中访问非静态的外围类对象。
  在一个普通的（非static）内部类中，通过一个特殊this引用可以链接到其外围类对象。嵌套类就没有这个特殊的this引用，这使它类似于一个static方法。
• 普通内部类的字段与方法只能放在类的外部层次上，所以普通内部类不能有static数据和static字段，也不能包含嵌套类。但是内部类可以包含所有这些东西。
• 接口内部的类。嵌套类可以作为接口的一部分，接口中任何类都自动是public和static的。可以在内部类实现其外围接口。

public interface ClassInInterface {
	void howdy();
	class Test implements ClassInInterface {
		@Override
		public void howdy() {
			System.out.println("Howdy!");
		}
	}
	public static void main(String[] args) {
		new Test().howdy();
	}
}
/* *Output:
 * Howdy!
 */

• 可以使用嵌套类来放置测试代码。

public class TestBed {
	public void f() {
		System.out.println("f()");
	}
	public static class Tester {
		public static void main(String[] args) {
			TestBed t = new TestBed();
			t.f();
		}
	}
}
/* *Output:
 * f()
 * /

这生成了一个独立的类TestBed$Tester(要运行这个程序，执行 java TestBed$Tester即可，在Unix/Linux系统中必须转义$)。可以使用这个类来做测试，但是不必在发布的产品中包含它，在将产品打包前可以简单地删除TestBed$Tester.class。

内部类的继承和覆盖

• 内部类的继承

class WithInner {
	class Inner {}
}
public class InheritInner extends WithInner.Inner {
	//! InheritInner() {} // Won`t compile
	InheritInner(WithInner wi) {
		wi.super();
	}
	public static void main(String[] args) {
		WithInner wi = new WithInner();
		InheritInner ii = new InheritInner(wi);
	}
}

InheritInner只继承内部类，而不是外围类。但是当要生成一个构造器时，默认的构造器并不算好，而且不能只是传递一个指向外围类的引用。此外必须在构造器内使用如下语法：enclosingClassReference.super(); 这样才提供了必要的引用，然后程序才能通过编译。

• 内部类的覆盖
  • 这两个类（Flower.Petal和Sunflower.Petal）是完全独立的两个实体，各自在自己的命名空间内。

class Flower {
	private Petal p;
	protected class Petal {
		public Petal() { System.out.println("Flower.Petal()"); }
	}
	public Flower() {
		System.out.println("New Flower()");
		p = new Petal();
	}
}
public class Sunflower extends Flower {
	public class Petal {
		public Petal() { System.out.println("Sunflower.Petal()"); }
	}
	public static void main(String[] args) {
		new Sunflower();
	}
}
/* *Output:
 * New Flower()
 * Flower.Petal()
 * /

• 内部类的覆盖：“Sunflower.Petal”通过“extends Flower.Petal” 明确继承了“Flower”的内部类“Petal”，并且覆盖了其中的方法。

class Flower {
	private Petal p;
	protected class Petal {
		public Petal() { System.out.println("Flower.Petal()"); }
		public void show() { System.out.println("Flower.Petal.show()"); }
	}
	public Flower() { System.out.println("new Flower()"); }
	public void insertPetal(Petal p) { this.p = p; }
	public void show() { p.show(); }
}
public class Sunflower extends Flower {
	public class Petal extends Flower.Petal {
		public Petal() { System.out.println("Sunflower.Petal()"); }
		public void show() { System.out.println("Sunflower.Petal.show()"); }
	}
	public Sunflower() { insertPetal(new Petal()); }
	public static void main(String[] args) {
		Flower f = new Sunflower();
		f.show();
	}
}
/* *Output:
 * new Flower()
 * Flower.Petal()
 * Sunflower.Petal()
 * Sunflower.Petal.show()
 * / 

内部类的作用

• 每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对内部类都没有影响。
• 内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。也就是说内部类允许继承多个非接口类型（类或抽象类）。（理解：多层嵌套内部类，每个类都继承不同的类，里层的内部类相当于实现了“多重继承”，因为内部类可以无条件获得外围类的成员对象，所以外围类继承的实现，里层的内部类都可以实现，并且还有自己继承的类的相关实现）
• 内部类可以都有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。
• 在单个外围类中，可以让多个内部类以不同的方式实现一个接口，或继承同一个类。
• 创建内部类对象的时刻并不依赖于外围类对象的创建。
• 内部类并没有令人迷惑的“is a”关系；它就是一个独立的实体。