学习笔记_抽象工厂模式

抽象工厂模式，在很多场景下都有应用。

 

它有以下的优点

1：封装性，每个产品的实现类不是高层模块要关心的，它所要关心 的是接口和抽象类，他不关心对象是如何创建出来，只有工厂类去关心，只要知道工厂类是谁，我们就能得到一个需要的对象。

 

2：产品家族的约束为非公开状态。而抽象工厂模式针对的是多个产品等级结构。当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

 

抽象产品

Java代码  

1. package com.gengu.抽象工厂;  
2. /** 
3.  * 抽象产品 
4.  * */  
5. public abstract class Product {  
6.     public abstract void dosomething();  
7. }  

 具体产品类

Java代码  

1. package com.gengu.抽象工厂;  
2.   
3. /** 
4.  * 产品A1 
5.  * */  
6. public class ProductA1 extends Product{  
7.   
8.     @Override  
9.     public void dosomething() {  
10.         System.out.println("这是产品A1");  
11.     }  
12. }  
13.   
14.   
15. package com.gengu.抽象工厂;  
16.   
17. /** 
18.  * 产品A 2 
19.  * */  
20. public class ProductA2 extends Product{  
21.   
22.     @Override  
23.     public void dosomething() {  
24.         System.out.println("这是产品A2");  
25.     }  
26.   
27. }  
28.   
29.   
30. package com.gengu.抽象工厂;  
31.   
32. /** 
33.  * 产品B1 
34.  * */  
35. public class ProductB1 extends Product{  
36.   
37.     @Override  
38.     public void dosomething() {  
39.         System.out.println("这里是产品B1");  
40.     }  
41. }  
42.   
43. package com.gengu.抽象工厂;  
44.   
45. public class ProductB2 extends Product{  
46.   
47.     @Override  
48.     public void dosomething() {  
49.         System.out.println("这里是产品B2");  
50.     }  
51. }  

 抽象工厂类

Java代码  

1. package com.gengu.抽象工厂;  
2.   
3. public abstract class Creater {  
4.   
5.     public abstract Product createProductA();  
6.       
7.     public abstract Product createProductB();  
8. }  

 具体工厂类

Java代码  

1. package com.gengu.抽象工厂;  
2.   
3. public class Creater1 extends Creater{  
4.   
5.     @Override  
6.     public Product createProductA() {  
7.           
8.         return new ProductA1();  
9.     }  
10.     @Override  
11.     public Product createProductB() {  
12.         return new ProductB1();  
13.     }  
14. }  
15.   
16. package com.gengu.抽象工厂;  
17.   
18. public class Creater2 extends Creater{  
19.   
20.     @Override  
21.     public Product createProductA() {  
22.           
23.         return new ProductA2();  
24.     }  
25.     @Override  
26.     public Product createProductB() {  
27.         return new ProductB2();  
28.     }  
29. }  

 测试类

Java代码  

1. package com.gengu.抽象工厂;  
2.   
3. public class Client {  
4.   
5.     public static void main(String[] args) {  
6.         Creater create1 = new Creater1();  
7.         Product productA1 = create1.createProductA();  
8.         productA1.dosomething();  
9.     }  
10. }  

 

抽象工厂方法从纵向上看，几乎没有可扩展性，假如我们想增加一个产品C，也就是说产品家族由原来的2个变为3个，程序将会有很大的变动，抽象工厂中就需要增加一个方法。这严重违背了开闭原则。并且抽象类是不喜欢被修改的。

但是从横向上来看，却对扩展性有了很好的支持，如果我们增加一个产品等级3，我们只需要在写一个Create3就可以了，这里又符合了开闭原则，有多少个产品等级就应该有多少个实现工厂类。每增加一个产品等级就相应的增加一个实现工厂类，这里的扩展性又很自然的体现出来了。

 

所以每个模式都是必须在合适的地方使用的。