内部类（3）：匿名内部类

1 匿名类

        请看下面这个例子：

public class Parcel7 {public Contents contents() {return new Contents() {private int i = 11;public int value() {return i;}};}public static void main(String[] args) {Parcel7 p = new Parcel7();Contents c = p.contents();}
}

        contents() 方法将返回值的生成与表示这个返回值的类定义结合在一起。另外，这个类是匿名的，它没有名字。更糟糕的是，看起来似乎是你正要创建一个Contents对象。但是然后（在到达语句结束的分号之前）你却说：“等一等，我想在这里插入一个类的定义”。

        这种奇怪的语法指的是：“创建一个继承自Contents的匿名类的对象。”通过new表达式返回的引用被自动向上转型为对Contents的引用。上述匿名内部类的语法是下述形式的简化形式：

public class Parcel7b {class MyContents implements Contents {private int i = 11;public int value() {return i;}}public Contents contents() {return new MyContents();}public static void main(String[] args) {Parcel7b p = new Parcel7b();Contents c = p.contents();}
}

        在这个匿名内部类中，使用了默认的构造器来生成Contents。下面的代码展示的是，如果你的基类需要一个有参数的构造器，应该怎么办：

public class Parcel8 {public Wrapping wrapping(int x) {return new Wrapping(x) {public int value() {return super.value() * 47;}};}public static void main(String[] args) {Parcel8 p = new Parcel8();Wrapping w = p.wrapping(10);}
}

        只需简单地传递合适的参数给基类的构造器即可，这里是将x传进new Wrapping(x)。尽管Wrapping只是一个具有具体实现的普通类，但它还是被其导出类当作公共“接口”来使用：

public class Wrapping {private int i;public Wrapping(int x) {i = x;}public int value() {return i;}
}

        你会注意到，Wrapping拥有一个要求传递一个参数的构造器，这使得事情变得更加有趣了。

        在匿名内部类末尾的分号，并不是用来标记此内部类结束的。实际上，它标记的是表达式的结束，只不过这个表达式正巧包含了匿名内部类罢了。因此，这与别的地方使用的分号是一致的。

        在匿名类中定义字段时，还能够对其执行初始化操作：

public class Parcel9 {public Destination destination(final String dest) {return new Destination() {private String label = dest;public String readLabel() {return label;}};}public static void main(String[] args) {Parcel9 p = new Parcel9();Destination d = p.destination("Tasmania");}
}

        如果定义一个匿名内部类，并且希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用是final的，就像你在destination() 的参数中看到的那样。如果你忘记了，将会得到一个编译时错误消息。

        如果只是简单地给一个字段赋值，那么此例中的方法是很好的。但是，如果想做一些类似构造器的行为，该怎么办呢？在匿名类中不可能有命名构造器（因为它根本没名字），但通过实例初始化，就能够达到为匿名内部类创建一个构造器的效果，就像这样：

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");}public void f() {System.out.println("In AnonymousConstructor.f()");}};}public static void main(String[] args) {Base base = getBase(47);base.f();}
}

        在此例中，不要求变量i一定是final的，因为i被传递给匿名类的基类构造器，它并不会在匿名类内部被直接使用。

        下面是带实例化的“parcel”形式。注意destination()的参数必须是final的，因为它们是在匿名类内部使用的：

public class Parcel10 {public Destination destination(final String dest, final float price) {return new Destination() {private int cost;{cost = Math.round(price);if (cost > 100) {System.out.println("Over budget!");}}private String label = dest;public String readLabel() {return label;}};}public static void main(String[] args) {Parcel10 p = new Parcel10();Destination d = p.destination("Tasmania", 101.395f);}
}

        在实例初始化操作的内部，可以看到有一段代码，它们不能作为字段初始化动作的一部分来执行（就是if语句）。所以对于匿名类而言，实例初始化的实际效果就是构造器。当然它受到了限制，你不能重载实例初始化方法，所以你仅有一个这样的构造器。

        匿名内部类与正规的继承相比有些受限，因为匿名内部类既可以扩展类，也可以实现接口，但是不能两者兼备。而且如果是实现接口，也只能实现一个接口。

2 再访工厂方法

        看看在使用匿名内部类时，Factories.java示例：

interface Service  {void method1();void method2();
}interface ServiceFactory {Service getService();
}class Implementation1 implements Service {private Implementation1() {}public void method1() {System.out.println("Implementation1 method1");}public void method2() {System.out.println("Implementation1 method2");}public static ServiceFactory factory = new ServiceFactory() {public Service getService() {return new Implementation1();}};
}class Implementation2 implements Service {private Implementation2() {}public void method1() {System.out.println("Implementation2 method1");}public void method2() {System.out.println("Implementation2 method2");}public static ServiceFactory factory = new ServiceFactory() {public Service getService() {return new Implementation2();}};
}public class Factories {public static void serviceConsumer(ServiceFactory fact) {Service s = fact.getService();s.method1();s.method2();}public static void main(String[] args) {serviceConsumer(Implementation1.factory);serviceConsumer(Implementation2.factory);}
}

        现在用于Implementation1和Implementation2的构造器都可以是private的，并且没有任何必要去创建作为工厂的具名类。另外，你经常只需要单一的工厂对象，因此在本例中它被创建为Service实现中的一个static域。这样所产生语法也更具有实际意义。

        Games.java示例也可以通过使用匿名内部类来改进：

interface Game {boolean move();
}interface GameFactory {Game getGame();
}class Checkers implements Game {private Checkers() {}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() {public Game getGame() {return new Checkers();}};
}class Chess implements Game {private Chess() {}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 s = factory.getGame();while (s.move());}public static void main(String[] args) {playGame(Chess.factory);playGame(Checkers.factory);}
}

        请记住优先使用类而不是接口。如果你的设计中需要某个接口，你必须了解它。否则，不到迫不得已，不要将其放到你的设计中。