JAVA设计模式之 抽象工厂模式【Abstract Factory Pattern】

http://blog.csdn.net/janice0529/article/details/40268217

一、概述

    抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。

二、适用场景

    为创建一组对象提供了一种解决方案。

三、UML类图

四、参与者

(1)    AbstractFactory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。如上图UML类图中的Factory。

(2)    ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。如上图UML类图中的Factory1 和Factory2。

(3)    AbstractProduct（抽象产品）：它为每种产品声明接口，如上图UML类图中的ProductA和ProductB。

(4)    ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。如上图UML类图中的ConcreteProductA1/A2/B1/B2。

五、用例学习

(1) 产品类型A接口: ProductA.java

[java] view plain copy

1. /** 
2.  * 产品类型A接口 
3.  * @author lvzb.software@qq.com 
4.  * 
5.  */  
6. public interface ProductA {  
7.   
8. }  

(2)产品类型B接口: ProductB.java

[java] view plain copy

1. /** 
2.  * 产品类型B接口 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public interface ProductB {  
7.   
8. }  

(3) 具体的A类型产品A1: ConcreteProductA1.java

[java] view plain copy

1. /** 
2.  * 具体的A类型产品A1 
3.  * @author lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ConcreteProductA1 implements ProductA {  
7.   
8.     public ConcreteProductA1(){  
9.         System.out.println("产品A1 已创建...");  
10.     }  
11. }  

(4) 具体的A类型产品A2: ConcreteProductA2.java

[java] view plain copy

1. /** 
2.  * 具体的A类型产品A2 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ConcreteProductA2 implements ProductA {  
7.   
8.     public ConcreteProductA2() {  
9.         System.out.println("产品A2 已创建...");  
10.     }  
11. }  

(5) 具体的B类型产品B1: ConcreteProductB1.java

[java] view plain copy

1. /** 
2.  * 具体的B类型产品B1 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ConcreteProductB1 implements ProductB {  
7.   
8.     public ConcreteProductB1(){  
9.         System.out.println("产品B1 已创建...");  
10.     }  
11. }  

(6) 具体的B类型产品B2: ConcreteProductB2.java

[java] view plain copy

1. /** 
2.  * 具体的B类型产品B2 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ConcreteProductB2 implements ProductB {  
7.   
8.     public ConcreteProductB2(){  
9.         System.out.println("产品B2 已创建...");  
10.     }  
11. }  

(7) 创建产品的工厂接口: Factory.java

[java] view plain copy

1. /** 
2.  * 创建产品族的工厂接口 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public interface Factory {  
7.       
8.     public ProductA createProductA();  
9.       
10.     public ProductB createProductB();  
11.   
12. }  

(8) 具体的"工厂一"类：只负责生产A1、B1等1族甲级优产品: ProductFactory1.java

[java] view plain copy

1. /** 
2.  * 具体的"工厂一"类：只负责生产A1、B1等1族甲级优产品 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ProductFactory1 implements Factory {  
7.   
8.     @Override  
9.     public ProductA createProductA() {  
10.         return new ConcreteProductA1();  
11.     }  
12.   
13.     @Override  
14.     public ProductB createProductB() {  
15.         return new ConcreteProductB1();  
16.     }  
17.   
18. }  

(9) 具体的"工厂二"类：只负责生产A2、B2等2族乙级劣产品: ProductFactory2.java

[java] view plain copy

1. /** 
2.  * 具体的"工厂二"类：只负责生产A2、B2等2族乙级劣产品 
3.  * @author  lvzb.software@qq.com 
4.  * 
5.  */  
6. public class ProductFactory2 implements Factory {  
7.   
8.     @Override  
9.     public ProductA createProductA() {  
10.         return new ConcreteProductA2();  
11.     }  
12.   
13.     @Override  
14.     public ProductB createProductB() {  
15.         return new ConcreteProductB2();  
16.     }  
17.   
18. }  

(10) 客户端 Client：Client.java

[java] view plain copy

1. public class Client {  
2.   
3.     public static void main(String[] args) {  
4.         Factory factory1 = null;  
5.         System.out.println("工厂一 是正规工厂  生产的产品是正品");  
6.         factory1 = new ProductFactory1();  
7.         factory1.createProductA();  
8.         factory1.createProductB();  
9.           
10.         System.out.println("-------------");  
11.           
12.         Factory factory2 = null;  
13.         System.out.println("工厂二 是黑工厂  生产的产品是次品");  
14.         factory2 = new ProductFactory2();  
15.         factory2.createProductA();  
16.         factory2.createProductB();  
17.           
18.     }  
19. }  

(11) 运行结果 如下：

[plain] view plain copy

1. 工厂一 是正规工厂  生产的产品是正品  
2. 产品A1 已创建...  
3. 产品B1 已创建...  
4. -------------  
5. 工厂二 是黑工厂  生产的产品是次品  
6. 产品A2 已创建...  
7. 产品B2 已创建...  

六、其他/扩展/优缺点

    抽象工厂模式是工厂方法模式的进一步延伸。在抽象工厂模式中，增加新的产品族很方便，但是增加新的产品等级结构很麻烦。