工厂方法模式

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把实例化推迟到子类。
把创建的对象认识为产品，“由子类决定要实例化的类是哪一个。工厂方法把实例化推迟到子类”意味着使用产品的客户代码，依赖的是产品的抽象类，而不是具体化的产品。
Java提供了new关键字，当我们在程序中需要使用一个对象时，就会想到它。
Pizza orderPizza() {
    Pizza pizza = new Pizza();
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
}

Pizza orderPizza(String type) {
    Pizza pizza;
    // 变化的部分
   if (type.equals("cheese")) {
        pizza = new CheesePizza();
    } else if (type.equals("greek")) {
        pizza = new GreekPizza();
    } else if (type.equals("pepperoni")) {
        pizza = new PepperoniPizza();
    }
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
}
  New没有什么不对的，关键在于orderPizza依赖于具体实现类。考虑到程序的扩展性，未来我们要创建哪些类型的Pizza对象是要经常改变的，对应于程序中if语句部分是要经常改变的。
  这违反了OCP原则，没有对修改关闭。解决方法：应用设计原则：封装变化，把程序中变化的部分和不变的部分隔离开。要把程序中创建产品的部分封装起来，封装对象的创建。
  定义简单工厂：

   public class SimplePizzaFactory {
        public Pizza createPizza(String type) {
            Pizza pizza = null;
            
            if (type.equals("cheese")) {
                pizza = new CheesePizza();
            } else if (type.equals("pepperoni")) {
                pizza = new PepperoniPizza();
            } else if (type.equals("clam")) {
                pizza = ClamPizza();
            } else if (type.equals("veggie")) {
                pizza = new VeggiePizza();
            }
            return pizza;
        }
    }

     该工厂提供了创建对象的接口createPizza(String type)。下面我们看一下，该简单工厂在PizzaStore中的应用：

     public class PizzaStore {
        SimpPizzaFactory factory;
       
        public PizzaStore(SimplePizzaFactory factory ) {
             this.factory = factory;
        }
       
        public Pizza orderPizza(String type) {
            Pizza pizza;
            pizza = factory.createPizza(type);
           
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
            return pizza;
        }
       
        //这里是其他方法
    }

      PizzaStore中，使用简单工厂来创建Pizza对象。简单工厂好处说明：
      把创建产品的代码封装到一个类中，当以后产品实现或者产品的种类改变时，只需要修改这个类即可，客户端PizzaStore代码不变。该简单工厂可以被许多客户使用。

    public abstract class PizzaStore {
           public Pizza orderPizza(String type) {
                Pizza pizza;

                pizza = createPizza(type);
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();

                return pizza;
          }

          // 在PizzaStore中工厂方法createPizza是抽象的
          abstract Pizza createPizza(String type);
    }

 

    public class NYPizzaStore extends PizzaStore {
          Pizza createPizza(String item) {
               if (item.equals("cheese")) {
                     return new NYStyleCheesePizza();
                } else if (item.equals("veggie")) {
                     return new NYStyleVeggiePizza();
                } else if (item.equals("clam")) {
                     return new NYStyleClamPizza();
                } else if (item.equals("pepperoni")) {
                     return new NYStylePepperoniPizza();
                } else
                    return null;
          }
    }

    public class ChicagoPizzaStore extends PizzaStore {
          Pizza createPizza(String item) {
             if (item.equals("cheese")) {
                   return new ChicagoStyleCheesePizza();
             } else if (item.equals("veggie")) {
                   return new ChicagoStyleVeggiePizza();
             } else if (item.equals("clam")) {
                   return new ChicagoStyleClamPizza();
             } else if (item.equals("pepperoni")) {
                   return new ChicagoStylePepperoniPizza();
             } else
                     return null;
         }
    }

 

      PizzaStore nyPizzaStore = new NYPizzaStore();

      nyPizzaStore.orderPizza("cheese");

       对工厂方法的认识：

     超类PizzaStore 中提供了抽象工厂方法abstract Pizza createPizza(String type)，该抽象工厂方法返回一个产品Pizza，该产品是抽象的。这样的话，工厂方法将客户（也就是PizzaStore中的代码，orderPizza()）和实际创建具体产品的代码分离开来。

     将一个orderPizza()方法和一个工厂方法联合起来，就可以成为一个框架。工厂方法模式中体现了平行的类层次：产品类和创建者类。抽象类：Pizza和PizzaStore，具体子类：NYStyle*Pizza、ChicagePizzaStore（*代表Cheese等种类）和NyPizzaStore、ChicagoPizzaStore。抽象创建者对应抽象产品，具体创建者对应具体产品。这就是类的层次结构。

     简单工厂模式和工厂方法模式的比较：

        1. 客户通过组合简单工厂，由工厂来创建产品。而工厂方法模式中，存在着继承关系，抽象类提供抽象工厂方法接口，而由具体子类去创建具体的产品。

     2. 简单工厂模式实现了客户端的OCP原则，但是如果产品发生变化，简单工厂本身代码仍然需要修改，因此简单工厂没有完全实现OCP原则。工厂方法模式中，当有新的产品出现时，只需要扩展出新的创建者对应该新的具体产品即可，完全符合OCP原则。

     4. 工厂方法模式体现了类层次结构。包括创建者类和产品类的层次对应关系。创建者类通过工厂方法来创建具体产品，并且创建者类可以应用框架，包含使用产品的客户代码（这个很强，否则只用来创建产品将是一种退化，我认为）。而简单工厂类只是创建产品，本身并不使用。

     3. 两者都封装了对象的创建，使客户与具体创建产品的代码解耦。

     最后，DIP原则（依赖倒置原则）：要依赖抽象，不要依赖具体类。不能让高层组件以来低层组件，而且，不管高层或底层组件，“两者”都应该依赖于抽象。工厂方法模式是遵循DIP原则最有威力的技巧之一。