抽象工厂模式

Posted 2020-09-29 WenJieWangFlyToWorld

抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的进一步抽象，其英文原话"Provide an interface for creating families of related or dependent objects without specifying their concrete classes",翻译，“为创建一组相关或相互依赖的对象提供一个借口，无需指定它们的具体类”。抽象工厂模式通常是用于创一族产品，并且这族产品分不同的等级；不同的具体工厂类生产不同等级的一族产品。抽象工厂模式也有四种角色：抽象工厂、具体工厂、抽象产品和具体产品。抽象工厂模式的类图如下：

 

可以看到产品族包括ProductA和ProductB两种产品，每个具体工厂都能生产这两种产品，只是ConcreteFactory1生产的等级为1的族产品；ConcreteFactory2生产的是等级为2的族产品。下面以上图为模型，写一个demo，测试抽象工厂模式。

抽象工厂：AbstractFactory接口

 

1. //抽象工厂，定义了生产族产品的方法；  
2. public interface AbstractFactory {  
3.     public ProductA factoryA();  
4.     public ProductB factoryB();  
5. }  

 

 

抽象产品：ProductA接口

 

 

1. //抽象产品A定义了产品的公共方法，产品A和B属于一个产品族  
2. public interface ProductA {  
3.     public void method1();  
4.     public void method2();  
5. }  

 

 

抽象产品：ProductB接口

 

 

1. //抽象产品B定义了产品的公共方法，产品A和B属于一个产品族  
2. public interface ProductB {  
3.     public void method1();  
4.     public void method2();  
5. }  

 

 

具体工厂（生产等级为2的族产品）：ConcreteFactory1类

 

 

1. //ConcreateFactory1是用来生产等级为1的产品A，B；  
2. public class ConcreateFactory1 implements AbstractFactory {  
3.   
4.     //生产等级为1的产品A  
5.     @Override  
6.     public ProductA factoryA() {  
7.         // TODO Auto-generated method stub  
8.         return new ConcreateProductA1();  
9.     }  
10.   
11.       
12.     //生产等级为1的产品B  
13.     @Override  
14.     public ProductB factoryB() {  
15.         // TODO Auto-generated method stub  
16.         return new ConcreateProductB1();  
17.     }  
18.   
19. }  

 

 

具体工厂（生产等级为1的族产品）：ConcreteFactory2类

 

1. public class ConcreateFactory2 implements AbstractFactory {  
2.   
3.     //生产等级为2的产品A  
4.     @Override  
5.     public ProductA factoryA() {  
6.         // TODO Auto-generated method stub  
7.         return new ConcreateProductA2();  
8.     }  
9.   
10.     //生产等级为2的产品B  
11.     @Override  
12.     public ProductB factoryB() {  
13.         // TODO Auto-generated method stub  
14.         return new ConcreateProductB2();  
15.     }  
16. }  

具体产品（等级为1的A产品）：ConcreteProductA1类

 

 

1. //等级为1的具体产品A  
2. public class ConcreateProductA1 implements ProductA {  
3.   
4.     @Override  
5.     public void method1() {  
6.         // TODO Auto-generated method stub  
7.         System.out.println("等级为1的产品A的method1()");  
8.     }  
9.   
10.     @Override  
11.     public void method2() {  
12.         // TODO Auto-generated method stub  
13.         System.out.println("等级为1的产品A的method2()");  
14.     }  
15. }  

具体产品（等级为2的A产品）：ConcreteProductA2类

 

 

 

1. //等级为2的具体产品A  
2. public class ConcreateProductA2 implements ProductA {  
3.   
4.     @Override  
5.     public void method1() {  
6.         // TODO Auto-generated method stub  
7.         System.out.println("等级为2的产品A的method1()");  
8.     }  
9.   
10.     @Override  
11.     public void method2() {  
12.         // TODO Auto-generated method stub  
13.         System.out.println("等级为2的产品A的method2()");  
14.     }  
15. }  

具体产品（等级为1的B产品）：ConcreteProductB1类

 

 

 

1. //等级为1的产品B  
2. public class ConcreateProductB1 implements ProductB{  
3.   
4.     @Override  
5.     public void method1() {  
6.         // TODO Auto-generated method stub  
7.         System.out.println("等级为1的产品B的method1()");  
8.     }  
9.   
10.     @Override  
11.     public void method2() {  
12.         // TODO Auto-generated method stub  
13.         System.out.println("等级为1的产品B的method2()");  
14.     }  
15. }  

具体产品（等级为2的B产品）：ConcreteProductB2类

 

 

 

1. //等级为2的产品B  
2. public class ConcreateProductB2 implements ProductB {  
3.   
4.     @Override  
5.     public void method1() {  
6.         // TODO Auto-generated method stub  
7.         System.out.println("等级为2的产品B的method1()");  
8.     }  
9.   
10.     @Override  
11.     public void method2() {  
12.         // TODO Auto-generated method stub  
13.         System.out.println("等级为2的产品B的method2()");  
14.     }  
15. }  

 

 

运行结果：

等级为1的产品A的method1()
等级为1的产品A的method2()
等级为1的产品B的method1()
等级为1的产品B的method2()
等级为2的产品A的method1()
等级为2的产品A的method2()
等级为2的产品B的method1()
等级为2的产品B的method2()

总结：

抽象工厂模式相对于工厂方法模式来说，每个具体工厂可以生产一族产品（即多种产品）；而工厂方法模式是具体工厂生产相应的具体产品，只能生产一种产品。当产品族中只有一种产品时抽象工厂模式退化成工厂方法模式。

 

转自：http://blog.csdn.net/liruikqn/article/details/12888511