【设计模式】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;
    }
}