工厂模式

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

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

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

类图：

披萨店  PizzaStore类：

/**
 * 披萨店    PizzaStore类    根据用户要的披萨类型来生产披萨
 * 简单工厂 示例
 * @author wly
 *
 */
public class PizzaStore {
    //声明一个SimplePizzaFactory类型的变量，用来保存简单工厂实例对象的引用
    public  SimplePizzaFactory  simplePizzaFactory;
    //通过构造器，来为PizzaStore类 注入  简单工厂实例对象
    public  PizzaStore(SimplePizzaFactory simplePizzaFactory)
    {
        this.simplePizzaFactory = simplePizzaFactory;
    }
    /**
     * 通过传入的pizzaType来决定产生哪种类型的披萨   
     * 然后将披萨prepare()  bake() cut() box()
     * @param pizzaType
     * @return
     */
    public Pizza  orderPizza(String  pizzaType)
    {
        //通过调用工厂对象的方法来产生披萨对象
        Pizza pizza =  simplePizzaFactory.creatPizza(pizzaType);
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }

}

简单工厂     SimplePizzaFactory类：

/**
 * 简单工厂类   SimplePizzaFactory类     
 * 通过简单工厂类的creatPizza方法来 产生一个  Pizza实例对象返回
 * @author wly
 *
 */
public class SimplePizzaFactory {
    /**
     * 根据传入的披萨类型  来产生相应的披萨   并返回
     * @param pizzaType
     * @return
     */
    public Pizza creatPizza(String pizzaType) {
        Pizza  pizza = null;
        if(pizzaType.equals("cheese"))
        {
            pizza = new CheesePizza();
        }
        else if(pizzaType.equals("veggie"))
        {
            pizza = new VeggiePizza();
        }
        else if(pizzaType.equals("clam"))
        {
            pizza = new ClamPizza();
        }
        return pizza;
    }

}

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

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

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

类图：

抽象父类  AbstractPizzaStore类：

/**
 * 这是抽象的父类   AbstractPizzaStore类
 * @author wly
 *
 */
public abstract class AbstractPizzaStore {
    /**
     * 通过传入的pizzaType来决定产生哪种类型的披萨   
     * 然后将披萨prepare()  bake() cut() box()
     * @param pizzaType
     * @return
     */
    public Pizza  orderPizza(String  pizzaType)
    {
        //通过调用工厂方法的方法来产生披萨对象
        Pizza pizza =  creatPizza(pizzaType);
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
    //父类中的工厂方法是抽象的  ，让具体的子类去决定如何实现工厂方法，产生Pizza对象
    public abstract Pizza creatPizza(String pizzaType);
        
}

具体子类  PizzaStore类：

/**
 * 这是具体的子类   PizzaStore类
 * @author wly
 *
 */

public class PizzaStore extends AbstractPizzaStore{
    /**
     * 实现父类中的抽象工厂方法  
     */
    @Override
    public Pizza creatPizza(String pizzaType) {
        Pizza  pizza = null;
        if(pizzaType.equals("cheese"))
        {
            pizza = new CheesePizza();
        }
        else if(pizzaType.equals("veggie"))
        {
            pizza = new VeggiePizza();
        }
        else if(pizzaType.equals("clam"))
        {
            pizza = new ClamPizza();
        }
        return pizza;
    }
}

　　

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

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

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

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

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

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

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

披萨店   PizzaStore类：

/**
 * 披萨店   PizzaStore类    
 * @author wly
 *
 */
public class PizzaStore {
    //声明一个变量，用来保存工厂实例对象的引用。
    private  AbstractFactory  factory;
    
    //通过构造器，注入抽象工厂的具体子类的实例工厂对象
    public PizzaStore(AbstractFactory  factory)
    {
        this.factory = factory;
    }
    
    public Pizza orderPizza(String pizzaType)
    {
        Pizza pizza = null;
        //通过抽象工厂的具体子类的工厂方法来产生需要的Pizza对象
        pizza = factory.creatPizza(pizzaType);
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
}

抽象工厂类     AbstractFactory类：

/**
 * 这是抽象工厂类   AbstractFactory类 
 * @author wly
 *
 */
public interface AbstractFactory {
    //这是抽象工厂的工厂方法，留给具体的子类去实现
    Pizza creatPizza(String pizzaType);

}

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

/**
 * 这是抽象工厂的具体的子工厂  NewYorkStyleFactory类 
 * @author wly
 *
 */
public class NewYorkStyleFactory implements AbstractFactory {
    /**
     * 实现抽象工厂中的抽象工厂方法  ，来产生具体的Pizza对象
     */
    @Override
    public Pizza creatPizza(String pizzaType) {
        Pizza  pizza = null;
        if(pizzaType.equals("cheese"))
        {
            pizza = new NewYorkStyleCheesePizza();
        }
        else if(pizzaType.equals("veggie"))
        {
            pizza = new NewYorkStyleVeggiePizza();
        }
        else if(pizzaType.equals("clam"))
        {
            pizza = new NewYorkStyleClamPizza();
        }
        return pizza;
    }

}

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

/**
 * 这是抽象工厂的具体的子工厂    ChicagoStyleFactory类 
 * @author wly
 *
 */
public class ChicagoStyleFactory implements AbstractFactory {
     /**
     * 实现抽象工厂中的抽象工厂方法  ，来产生具体的Pizza对象
     */
    @Override
    public Pizza creatPizza(String pizzaType) {
        Pizza  pizza = null;
        if(pizzaType.equals("cheese"))
        {
            pizza = new ChicagoStyleCheesePizza();
        }
        else if(pizzaType.equals("veggie"))
        {
            pizza = new ChicagoStyleVeggiePizza();
        }
        else if(pizzaType.equals("clam"))
        {
            pizza = new ChicagoStyleClamPizza();
        }
        return pizza;
    }
}

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

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

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

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

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

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

             对象来调用工厂方法的。