工厂模式

简单工厂：简单工厂通过把产生一个实例对象的过程，交给一个简单工厂的类去完成。

简单工厂严格来说，算不上是一种设计模式，反而比较像是一种编程习惯。

一个披萨店：根据用户的点的披萨类型，生产出相应类型的披萨，然后经过烘焙，切割，装盒，返回给用户。

类图：

披萨店 PizzaStore类：

 1 /**
 2  * 披萨店    PizzaStore类    根据用户要的披萨类型来生产披萨
 3  * 简单工厂 示例
 4  * @author wly
 5  *
 6  */
 7 public class PizzaStore {
 8     //声明一个SimplePizzaFactory类型的变量，用来保存简单工厂实例对象的引用
 9     public  SimplePizzaFactory  simplePizzaFactory;
10     //通过构造器，来为PizzaStore类 注入  简单工厂实例对象
11     public  PizzaStore(SimplePizzaFactory simplePizzaFactory)
12     {
13         this.simplePizzaFactory = simplePizzaFactory;
14     }
15     /**
16      * 通过传入的pizzaType来决定产生哪种类型的披萨   
17      * 然后将披萨prepare()  bake() cut() box()
18      * @param pizzaType
19      * @return
20      */
21     public Pizza  orderPizza(String  pizzaType)
22     {
23         //通过调用工厂对象的方法来产生披萨对象
24         Pizza pizza =  simplePizzaFactory.creatPizza(pizzaType);
25         
26         pizza.prepare();
27         pizza.bake();
28         pizza.cut();
29         pizza.box();
30         
31         return pizza;
32     }
33 
34 }

简单工厂 SimplePizzaFactory类：

 1 /**
 2  * 简单工厂类   SimplePizzaFactory类     
 3  * 通过简单工厂类的creatPizza方法来 产生一个  Pizza实例对象返回
 4  * @author wly
 5  *
 6  */
 7 public class SimplePizzaFactory {
 8     /**
 9      * 根据传入的披萨类型  来产生相应的披萨   并返回
10      * @param pizzaType
11      * @return
12      */
13     public Pizza creatPizza(String pizzaType) {
14         Pizza  pizza = null;
15         if(pizzaType.equals("cheese"))
16         {
17             pizza = new CheesePizza();
18         }
19         else if(pizzaType.equals("veggie"))
20         {
21             pizza = new VeggiePizza();
22         }
23         else if(pizzaType.equals("clam"))
24         {
25             pizza = new ClamPizza();
26         }
27         return pizza;
28     }
29 
30 }

简单工厂的类型形式：静态工厂

上面两种工厂形式，都算不上真正的设计模式，下面来介绍真正的两种工厂模式：

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

类图：

抽象父类 AbstractPizzaStore类：

 1 /**
 2  * 这是抽象的父类   AbstractPizzaStore类
 3  * @author wly
 4  *
 5  */
 6 public abstract class AbstractPizzaStore {
 7     /**
 8      * 通过传入的pizzaType来决定产生哪种类型的披萨   
 9      * 然后将披萨prepare()  bake() cut() box()
10      * @param pizzaType
11      * @return
12      */
13     public Pizza  orderPizza(String  pizzaType)
14     {
15         //通过调用工厂方法的方法来产生披萨对象
16         Pizza pizza =  creatPizza(pizzaType);
17         
18         pizza.prepare();
19         pizza.bake();
20         pizza.cut();
21         pizza.box();
22         
23         return pizza;
24     }
25     //父类中的工厂方法是抽象的  ，让具体的子类去决定如何实现工厂方法，产生Pizza对象
26     public abstract Pizza creatPizza(String pizzaType);
27         
28 }

具体子类 PizzaStore类：

 1 /**
 2  * 这是具体的子类   PizzaStore类
 3  * @author wly
 4  *
 5  */
 6 
 7 public class PizzaStore extends AbstractPizzaStore{
 8     /**
 9      * 实现父类中的抽象工厂方法  
10      */
11     @Override
12     public Pizza creatPizza(String pizzaType) {
13         Pizza  pizza = null;
14         if(pizzaType.equals("cheese"))
15         {
16             pizza = new CheesePizza();
17         }
18         else if(pizzaType.equals("veggie"))
19         {
20             pizza = new VeggiePizza();
21         }
22         else if(pizzaType.equals("clam"))
23         {
24             pizza = new ClamPizza();
25         }
26         return pizza;
27     }
28 }

抽象工厂模式：抽象工厂模式是在简单工厂的基础之上，对简单工厂进行抽象，形成抽象工厂类和子类工厂类。

这样，我们在需要实例对象Pizza的PizzaStore类中，通过构造器注入工厂对象时，可以面向抽象工厂类进行编程，在运行时确定是哪个子类工厂类。

这样为比较复杂的实例对象Pizza类的实例化，提供了比较有弹性的工厂生产。

现在有一家披萨店，它有两个供货商：纽约风味的供货商，芝加哥风味的供货商。

纽约风味的供货商，提供纽约风味芝士披萨，纽约风味蔬菜披萨，纽约风味蛤蜊披萨

芝加哥风味的供货商，提供芝加哥风味芝士披萨，芝加哥风味蔬菜披萨，芝加哥风味蛤蜊披萨

根据用户的不同选择来产生，不同的披萨：

披萨店 PizzaStore类：

 1 /**
 2  * 披萨店   PizzaStore类    
 3  * @author wly
 4  *
 5  */
 6 public class PizzaStore {
 7     //声明一个变量，用来保存工厂实例对象的引用。
 8     private  AbstractFactory  factory;
 9     
10     //通过构造器，注入抽象工厂的具体子类的实例工厂对象
11     public PizzaStore(AbstractFactory  factory)
12     {
13         this.factory = factory;
14     }
15     
16     public Pizza orderPizza(String pizzaType)
17     {
18         Pizza pizza = null;
19         //通过抽象工厂的具体子类的工厂方法来产生需要的Pizza对象
20         pizza = factory.creatPizza(pizzaType);
21         
22         pizza.prepare();
23         pizza.bake();
24         pizza.cut();
25         pizza.box();
26         
27         return pizza;
28     }
29 }

抽象工厂类 AbstractFactory类：

 1 /**
 2  * 这是抽象工厂类   AbstractFactory类 
 3  * @author wly
 4  *
 5  */
 6 public interface AbstractFactory {
 7     //这是抽象工厂的工厂方法，留给具体的子类去实现
 8     Pizza creatPizza(String pizzaType);
 9 
10 }

抽象工厂的具体实现类 NewYorkStyleFactory类：

 1 /**
 2  * 这是抽象工厂的具体的子工厂  NewYorkStyleFactory类 
 3  * @author wly
 4  *
 5  */
 6 public class NewYorkStyleFactory implements AbstractFactory {
 7     /**
 8      * 实现抽象工厂中的抽象工厂方法  ，来产生具体的Pizza对象
 9      */
10     @Override
11     public Pizza creatPizza(String pizzaType) {
12         Pizza  pizza = null;
13         if(pizzaType.equals("cheese"))
14         {
15             pizza = new NewYorkStyleCheesePizza();
16         }
17         else if(pizzaType.equals("veggie"))
18         {
19             pizza = new NewYorkStyleVeggiePizza();
20         }
21         else if(pizzaType.equals("clam"))
22         {
23             pizza = new NewYorkStyleClamPizza();
24         }
25         return pizza;
26     }
27 
28 }

抽象工厂的具体实现类 ChicagoStyleFactory类：

 1 /**
 2  * 这是抽象工厂的具体的子工厂    ChicagoStyleFactory类 
 3  * @author wly
 4  *
 5  */
 6 public class ChicagoStyleFactory implements AbstractFactory {
 7      /**
 8      * 实现抽象工厂中的抽象工厂方法  ，来产生具体的Pizza对象
 9      */
10     @Override
11     public Pizza creatPizza(String pizzaType) {
12         Pizza  pizza = null;
13         if(pizzaType.equals("cheese"))
14         {
15             pizza = new ChicagoStyleCheesePizza();
16         }
17         else if(pizzaType.equals("veggie"))
18         {
19             pizza = new ChicagoStyleVeggiePizza();
20         }
21         else if(pizzaType.equals("clam"))
22         {
23             pizza = new ChicagoStyleClamPizza();
24         }
25         return pizza;
26     }
27 }

通过对比三个设计模式：简单工厂，工厂方法，抽象工厂

三者的相同点都是具有一个产生 PizzaStore组件所依赖的Pizza组件的工厂方法creatPizza()

三者的不同点是使用何种方式来调用工厂方法creatPizza

简单工厂：通过构造器注入一个具体的工厂实例对象，来调用属于这个工厂实例的工厂方法

工厂方法：工厂方法通过具体的子类自己来调用属于自己实例的工厂方法，将产生所依赖的Pizza组件的行为，推迟到具体子类中去

抽象工厂：在简单工厂的基础之上，将工厂类在进行抽象，形成抽象工厂父类和具体工厂子类。面向抽象工厂父类编程，在运行时，是通过具体工厂子类的实例

对象来调用工厂方法的。