java 内部类，

内部类定义方式

• 内部类定义在成员位置上，可被成员修饰符修饰；
• 内部类定义在局部时，不得被成员修饰符修饰；
  
• 内部类中有静态成员（final static变量除外）时，该类也应为static；
• 非嵌套类的内部类不能有static数据和static字段，也不能包含嵌套类；
• 外部类中静态方法访问内部类时，内部类也必须为static；
  
• 类的内部类可再定义类；
• 内部类不能被覆盖。

访问方式

• 内部类（不管是否在成员位置）可直接访问外部类的成员，包括private（因为内部类持有外部类的引用，格式：Outer.this）；
• 内部类定义在局部时，只能访问被final修饰的局部变量；
  
• 外部类访问内部类时，必须建立内部类对象；
• 内部类定义在外部类成员位置上而非私有时，可在其他外部类中创建该类对象。格式：Outer.Inner inner = outer.new Inner();
• 静态内部类（嵌套类）的创建可不需要对外部类对象的引用。

class Outer {
	static class Inner {}
}
public class Test {
	public static void main(String[] args) {
		Outer.Inner inner = new Outer.Inner();
	}
}

应用

    迭代器设计模式——黑箱聚集与内禀迭代子

interface Iterator {
	boolean hasNext();
	void next();
	//...
}
interface Container {
	Iterator createIterator();
}
class Outer implements Container {
	private class Inner implements Iterator {
		public boolean hasNext() {
			return false;
		}
		public void next() {}
	}
	public Iterator createIterator() {
		return new Inner();
	}
}

匿名内部类（Anonymous inner class）

（1）实现某类型的接口，并可创建并返回对其的引用；

（2）想创建类辅助你的解决方案，但又不希望这个类是公共可用的；

（3）为保证程序可读性，匿名内部类中方法最好不超过3个。

    此时可使用局部内部类或匿名内部类。一般在两种情况下，使用局部内部类而不是匿名内部类：需要重载构造器；需要不止一个该内部类对象。

嵌套类（Nested class）

    如果不希望内部类对象与其外围类对象间有联系，可将内部类声明为static。

（1）创建嵌套类对象，并不需要外部类对象；

（2）不能从嵌套类对象中访问非静态外部类对象。

接口内部的类

嵌套类可作为接口的一部分，接口中的类默认是public static的。

内部类的意义

（1）内部类使多重继承的解决方案变得完整；

（2）通过内部类可以提供闭包的功能；

（3）内部类与控制框架。

public abstract class Event {
	private long eventTime;
	protected final long delayTime;
	public Event(long delayTime) {
		this.delayTime = delayTime;
		start();
	}
	public void start() {
		eventTime = System.nanoTime() + delayTime;
	}
	public boolean ready() {
		return System.nanoTime() >= eventTime;
	}
	public abstract void action();
}
public class Controler {
	private List<Event> eventList = new ArrayList<Event>();
	public void addEvent(Event e) {
		eventList.add(e);
	}
	public void run() {
		while(eventList.size() > 0) {
			for(Event e : new ArrayList<Event>(eventList)) {
				if(e.ready()) {
					System.out.println(e);
					e.action();
					eventList.remove(e);
				}
			}
		}
	}
}
public class GreenHouseControls extends Controler {
	private boolean light = false;
	public class LightOn extends Event {
		public LightOn(long delayTime) { super(delayTime);}
		public void action() { light = true; }
		public String toString() { return "Light is on"; }
	}
	public class LightOff extends Event {
		public LightOff(long delayTime) { super(delayTime); }
		public void action() { light = false; }
		public String toString() { return "Light is off"; }
	}
}
public class Test {
	public static void main(String[] args) {
		GreenHouseControls gc = new GreenHouseControls();
		gc.addEvent(gc.new LightOn(0));
		gc.addEvent(gc.new LightOff(200));
		gc.run();
	}
}