【设计模式】FactoryPattern工厂模式

Factory Pattern

简单工厂模式

将变化的部分封装起来

 //简单工厂
 class SimpleProductFactory{
     Product createProduct(String type){
         //选择--varied
         if (type.equals("type1")){
             product = new ...
         }else if(...){
             ...
         }else{
             ...
         }
         return product;
     }
 }

 Product orderProduct(String type){

     SimpleProductFactory factory = new SimpleProductFactory();

     Product product = factory.createProduct(type);

     //other operations...

 }

 //进一步封装
 public class ProductStore{
     SimpleProductFactory factory;
     public ProductStore(SimpleProductFactory factory){
         this.factory = factory;
     }

     public Product orderProduct(String type){
         Product product = factory.createProduct(type);
         //other operations...

     }
 }

 /*
 这一步：
 使用了一个Store类，包含了生产产品的方法。
 factory在构造函数的时候传进来。
 推迟了new操作。
 */

工厂方法模式

It defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclass.

 //工厂方法模式
 public abstract class ProductStore{
     public Product orderProduct(String type){
         Product product = createProduct(type);
         //product.test();
         //other methods...
         return product;
     }

     protected abstract Product createProduct; //->工厂方法
     //other methods...
 }

抽象工厂模式

Abstract Factory creates a family of concrete objects together needed by the client.

 //抽象工厂模式

 //原料工厂
 public interface ProductIngredientFactory{

     public Ingredient1 createIngredient1();
     public Ingredient2 createIngredient2();
     public Ingredient3 createIngredient3();
     //...
 }
 //具体的原料工厂类
 //实现每一种对应的ingredient

 public class Product1 extends Product{
     ProductIngredientFactory ingredientFactory;
     public Product1(ProductIngredientFactory ingredientFactory){
         this.ingredientFactory = ingredientFactory;
     }
     void prepare(){
         ingredient1 = ingredientFactory.createIngredient1();
         ingredient2 = ingredientFactory.createIngredient2();
         ingredient3 = ingredientFactory.createIngredient3();
     }

 }

 //重构产品商店
 //每个具体的商店（继承自抽象的ProductStore）都要实现里面的工厂方法
 //可能不止createProduct这一种工厂方法
 //在这个工厂方法里，实现具体工厂的实例（包含了多个abstract方法），将具体工厂传入产品中

 public class ProductStore1 extends ProductStore{

     //implement an abstract method
     protected Product createProduct(String type){
         Product product = null;
         ProductIngredientFactory ingredientFactory = new ProductIngredientFactory1(); //指定是原料工厂1，具体的类

         if (type.equals("type1")){
             product = new Product1(ingredientFactory);
         }else if(...){
             ...
         }else{
             ...
         }
         return product;
     }
 }