【设计模式】抽象工厂模式

　　抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一个产品族。抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，其属于对象创建型模式。

　　抽象工厂模式中包含四个角色：抽象工厂用于声明生成抽象产品的方法；具体工厂实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。

　　抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建，而且每次可以通过具体工厂类创建一个产品族中的多个对象，增加或者替换产品族比较方便，增加新的具体工厂和产品族很方便；但是它增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。

　　抽象工厂模式适用情况包括：一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节；系统中有多于一个的产品族，而每次只使用其中某一产品族；属于同一个产品族的产品将在一起使用；系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

　　我们以生产一套手机产品为例，手机包括手机本身和外接耳机。我们需要生产不同品牌的手机，那么我们可以针对不同品牌的手机产品分别做一个工厂专门用于生产此品牌产品。

　　首先创建一个手机抽象类，定义手机共性的内容：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：抽象手机类 
4.  * @author win2016 
5.  * 
6.  */  
7. public abstract class Phone {  
8.       
9.     protected String brand; // 手机品牌  
10.     protected String model; // 手机型号  
11.   
12.     public Phone(String brand,String model) {  
13.         this.brand = brand;  
14.         this.model = model;  
15.     }  
16.       
17.     public abstract void call();  // 打电话  
18.     public abstract void sendMessage();  // 发信息  
19.   
20. }</span>  

　　再来一个耳机抽象类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：耳机抽象类 
4.  * @author周家林
   
5.  * 
6.  */  
7. public abstract class Headset{  
8.     protected String brand; // 耳机品牌  
9.     //省略方法声明  
10. }</span>  

　　来一个三星品牌耳机类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：三星耳机类 
4.  * @author周家林 
5.  * 
6.  */  
7. public class SamsungHeadset extends Headset{  
8.     public SamsungHeadset(){  
9.         System.out.println("三星耳机");  
10.     }  
11. }  
12. </span>  

　　三星手机类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求:三星品牌手机类 
4.  * @author 周家林 
5.  * 
6.  */  
7. public class SamsungPhone extends Phone{  
8.       
9.     public SamsungPhone(String brand, String model) {  
10.         super(brand, model);  
11.     }  
12.   
13.     @Override  
14.     public void call() {  
15.         System.out.println(" 使用 "+this.brand+" "+this.model+" 打电话 ");  
16.     }  
17.   
18.     @Override  
19.     public void sendMessage() {  
20.         System.out.println(" 使用 "+this.brand+" "+this.model+" 发短信 ");  
21.     }  
22. }</span>  

　　苹果耳机类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：苹果耳机类 
4.  * @author 周家林 
5.  * 
6.  */  
7. public class AppleHeadset extends Headset{  
8.     public AppleHeadset(){  
9.         System.out.println("苹果耳机");  
10.     }  
11. }</span>  

　　苹果手机类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：苹果手机类 
4.  * @author 周家林 
5.  * 
6.  */  
7. public class ApplePhone extends Phone{  
8.   
9.     public ApplePhone(String brand, String model) {  
10.         super(brand, model);  
11.     }  
12.   
13.     @Override  
14.     public void call() {  
15.         System.out.println(" 使用 "+this.brand+" "+this.model+" 打电话 ");  
16.     }  
17.   
18.     @Override  
19.     public void sendMessage() {  
20.         System.out.println(" 使用 "+this.brand+" "+this.model+" 发短信 ");  
21.     }  
22.   
23. }</span>  

　　产品线：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  *  产品线 
4.  */  
5. public abstract class ProductFactory {  
6.   
7.     // 生产手机  
8.     public abstract Phone makePhone();  
9.     // 生产耳机  
10.     public abstract Headset makeHeadset();  
11. }</span>  

　　三星产品工厂：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：三星产品工厂 
4.  * @author 周家林 
5.  * 
6.  */  
7. public class SamsungProductionLine extends ProductFactory {  
8.   
9.     @Override  
10.     public Phone makePhone() {  
11.     return new SamsungPhone("Samsung","Galaxy");  
12.     }  
13.   
14.     @Override  
15.     public Headset makeHeadset() {  
16.         return new SamsungHeadset();  
17.     }  
18. }</span>  

　　苹果代工厂：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：苹果工厂 
4.  * @author周家林 
5.  * 
6.  */  
7. public class AppleProductionLine extends ProductFactory {  
8.   
9.     @Override  
10.     public Phone makePhone() {  
11.         return new ApplePhone("Apple","iPhone 5");  
12.     }  
13.   
14.     @Override  
15.     public Headset makeHeadset() {  
16.         return new AppleHeadset();  
17.     }  
18.   
19. }</span>  

　　测试类：

[java] view plain copy

1. <span style="font-size:18px;">package 抽象工厂;  
2. /** 
3.  * 需求：测试类 
4.  * @author 周家林
5.  * 
6.  */  
7. public class Test {  
8.     public static void main(String[] args) {  
9.         ProductFactory productionLine;  // 抽象工厂，手机生产线  
10.         Phone phone; // 抽象产品， 手机  
11.         Headset headset; // 抽象产品， 耳机  
12.   
13.         productionLine = new AppleProductionLine();  // 具体工厂  苹果生产线  
14.         phone = productionLine.makePhone();           // 生产出的具体产品是苹果手机  
15.         headset = productionLine.makeHeadset();   // 生产出的具体产品是苹果耳机  
16.   
17.         phone.call();  
18.         phone.sendMessage();  
19.           
20.     }  
21. }</span>  

　　通过这样，我们就可以方便的生产苹果、三星品牌的手机了。

　　

　　抽象工厂的优缺点：

　　优点：抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有 的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。

　　另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

　　缺点：在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。