匿名内部类工厂方法-内部类

看一段匿名内部类的代码，刚开始我以为内部类不就是写在类内部的类嘛，看了书好吧 我还是太年轻了。它有这么多功能我都没有用过。看一个例子

interface Game { 
	boolean move(); 
}
interface GameFactory {
	Game getGame(); 
}

class Checkers implements Game {
	private Checkers() {}//构造方法用的丝private修饰，外部不可访问
	private int moves = 0;
	private static final int MOVES = 3;

	public boolean move() {
		System.out.println("Checkers move " + moves);
		return ++moves != MOVES;
	}
	public static GameFactory factory = new GameFactory() {
		@Override
		public Game getGame() {
			//返回一个Checkers对象
			//因为是内部类所有有权限访问private的构造函数
			return new Checkers();
		}
	};
}

class Chess implements Game {
	private Chess() {}//also private
	private int moves = 0;
	private static final int MOVES = 4;
	public boolean move() {
		System.out.println("Chess move " + moves);
		return ++moves != MOVES;
	}
	//使用匿名内部内
	public static GameFactory factory = new GameFactory() {
		public Game getGame() {
			return new Chess();
		}
	};
	
}

public class Games {
	public static void playGame(GameFactory factory) {
		Game game = factory.getGame();
		while(game.move())
		{
			//
		}
	}

	public static void main(String[] args) {
		playGame(Checkers.factory);
		playGame(Chess.factory);
	}
}

输出结果

Checkers move 0
Checkers move 1
Checkers move 2
Chess move 0
Chess move 1
Chess move 2
Chess move 3

整个程序的效果很简单，就是让Checkers移动三步，Chess移动四步。

Games中定义了playGame的静态方法，可以有main直接调用。需要的参数是GameFactory，即只要传入实现这个接口的类的引用即可（多态）。

以前的做法就是创建一个类实现GameFactory这个接口，当然这样没问题但是这样会浪费，因为这个类只用了一次，后面就被回收了，所有用匿名内部类的话效果更好，代码还更简洁。
public static GameFactory factory = new GameFactory()...

这一行其实也可以直接理解为写了一个类实现了GameFactory接口，然后重写了里面的getGame方法，方法内返回的是外部类Chess的引用。 只不过是省略了一些步骤而已。

当然也可以直接向下面这样写一个类

class CheckersFactory implements GameFactory {
	public Game getGame() {
		return new Checkers();
	}
}

但是这样的话还有一个要求，Checkers中的构造函数不能写成private的需要是default的。当然，private的更安全一些，还是尽量选用匿名内部类比较好。