内部类（再论工厂模式）

>>>接口与工厂模式<<<
接口典型的应用就是多继承，而工厂方法设计模式能生成实现同一接口的对象，这与我们直接在使用的地方new某个实现对象是不同的，我们通过工厂对象上调用是业务实现对象创建方法，而该工厂对象将生成接口的某个业务实现的对象，理念上，我们的代码将完全与接口分离，这使得我们可以透明地将某个实现替换为另一个实现。下面的实例展示了工厂方法的结构：

Java代码  

1. // 业务接口  
2. interface Service {  
3.   void method1();  
4.   void method2();  
5. }  
6. // 业务工厂  
7. interface ServiceFactory {  
8.   Service getService();  
9. }  
10. // 业务1的实现  
11. class Implementation1 implements Service {  
12.   Implementation1() {} // 包访问  
13.   public void method1() {System.out.println("Implementation1 method1");}  
14.   public void method2() {System.out.println("Implementation1 method2");}  
15. }   
16. // 业务1的工厂  
17. class Implementation1Factory implements ServiceFactory {  
18.   public Service getService() {  
19.     return new Implementation1();  
20.   }  
21. }  
22. //业务2的实现  
23. class Implementation2 implements Service {  
24.   Implementation2() {} // 包访问  
25.   public void method1() {System.out.println("Implementation2 method1");}  
26.   public void method2() {System.out.println("Implementation2 method2");}  
27. }  
28. //业务2的工厂  
29. class Implementation2Factory implements ServiceFactory {  
30.   public Service getService() {  
31.     return new Implementation2();  
32.   }  
33. }   
34. //工厂应用  
35. public class Factories {  
36.   public static void serviceConsumer(ServiceFactory fact) {  
37.  // 通过不同的工厂获得不同的业务实现  
38.     Service s = fact.getService();  
39.     s.method1();  
40.     s.method2();  
41.   }  
42.   public static void main(String[] args) {  
43.     serviceConsumer(new Implementation1Factory());  
44.     // 业务实现可以透明的改变:  
45.     serviceConsumer(new Implementation2Factory());  
46.   }  
47. } /* Output: 
48. Implementation1 method1 
49. Implementation1 method2 
50. Implementation2 method1 
51. Implementation2 method2 
52. */  

 
如果不使用工厂方法，你的代码就必须在使用处指定将要创建的Service的确切类型，以便调用合适的构造器。为什么需要这种额外的间接性呢？一个常见的原因就是想要创建框架，业务实例的生产过程对客户是透明的，而且还可以在工厂方法返回实例前对业务对象进行额外处理。

 

>>>内部类与工厂模式<<<
看看再使用匿名内部类来修改上面的程序：

Java代码  

1. interface Service {  
2.   void method1();  
3.   void method2();  
4. }  
5. interface ServiceFactory {  
6.   Service getService();  
7. }   
8. class Implementation1 implements Service {  
9.   private Implementation1() {}// 私有的，只能通过工厂方法来返回  
10.   public void method1() {System.out.println("Implementation1 method1");}  
11.   public void method2() {System.out.println("Implementation1 method2");}  
12.   public static ServiceFactory factory = // 静态成员，只需一个工厂即可  
13.     new ServiceFactory() {// 使用匿名类来实现工厂接口  
14.       public Service getService() {  
15.      // 但需多个业务对象，每次调用工厂方法都会获得一个业务实现对象  
16.         return new Implementation1();  
17.       }  
18.     };  
19. }   
20. class Implementation2 implements Service {  
21.   private Implementation2() {}// 私有的，只能通过工厂方法来返回  
22.   public void method1() {System.out.println("Implementation2 method1");}  
23.   public void method2() {System.out.println("Implementation2 method2");}  
24.   public static ServiceFactory factory =  
25.     new ServiceFactory() {  
26.       public Service getService() {  
27.         return new Implementation2();  
28.       }  
29.     };  
30. }   
31. public class Factories {  
32.   public static void serviceConsumer(ServiceFactory fact) {  
33.     Service s = fact.getService();  
34.     s.method1();  
35.     s.method2();  
36.   }  
37.   public static void main(String[] args) {  
38.     serviceConsumer(Implementation1.factory);  
39.     serviceConsumer(Implementation2.factory);  
40.   }  
41. }  

修改后Implementation1与Implementation2的构造器都可以是private的，并且没有任何必要去创建具有具体名字的工厂类，另外，你经常只需要一个工厂对象即可，因此在本例中它被创建为Service实现的一个static域，这样更具有实际意义。修改后的程序是多么的完美!