工廠模式

簡單工廠模式

簡單工廠模式其實不是一個模式，反而比較像一個編程習慣。

/**
 * 披薩類
 *
 * @author Colin
 * @create 2018-04-17
 **/
public abstract class Pizza {

    public abstract void prepare();

    public abstract void bake();

    public abstract void  cut();

    public abstract void box();
}

/**
 *  pizza 商店
 *
 * @author Colin
 * @create 2018-04-17
 **/
public class PizzaStore {

    private SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory){
        this.factory=factory;
    }

    /**
     *  訂購pizza
     * @param type pizza 類型
     * @return
     */
    public Pizza orderPizza(String type){
        Pizza pizza=factory.createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

/**
 * pizza 工廠類
 *
 * @author Colin
 * @create 2018-04-17
 **/
public class SimplePizzaFactory {

    private static final String CHEESE="cheese";

    private static final String VEGGIE="veggie";

    public Pizza createPizza(String type){
        Pizza pizza =null;
        if (CHEESE.equals(type)){
            pizza=new CheesePizza();
        }else if (VEGGIE.equals(type)){
            pizza=new VeggiePizza();
        }
        return  pizza;
    }
}

工廠方法模式

定義了一個建立對象的接口，但由子類決定要實例化的類是哪個。工廠方法讓類把實例化推遲到子類。 全部子類必須實現Creator抽象類中的factoryMethod方法，ConcreteCreator負責一個或多個具體產品，只有ConcreteCreator類知道如何建立這些產品

/**
 * pizza 商店
 *
 * @author Colin
 * @create 2018-04-17
 **/
public abstract class AbstractPizzaStore {

    public Pizza orderPizza(String type){
        Pizza pizza=createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;

    }

    /**
     * pizza 建立
     * @param type
     * @return
     */
    protected abstract Pizza createPizza(String type);
}

/**
 * 紐約pizza商店
 *
 * @author Colin
 * @create 2018-04-23
 **/
public class NYPizzaStore extends AbstractPizzaStore {


    @Override
    protected Pizza createPizza(String type) {
        if ("cheese".equals(type)){
            return  new NyStyleCheesePizza();
        }else{
            return null;
        }
    }
}

/**
 * pizza 類
 *
 * @author Colin
 * @create 2018-04-17
 **/
public abstract class Pizza {
    /** 名稱 **/
    String name;
    /** 麪糰 **/
    String dough;
    /** 佐料 **/
    String sauce;



    void prepare(){
        System.out.println("Preparing "+name);
        System.out.println("Tossing dough");
        System.out.println("Adding sauce....");

    }

    void  bake(){
        System.out.println("Bake for 25 minutes at 350");
    }

    void cut(){
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box(){
        System.out.println("Please pizza in official PizzaStore box");
    }

    public String getName(){
        return  name;
    }

}


/**
 * 紐約 芝士 pizza
 *
 * @author Colin
 * @create 2018-04-17
 **/
public class NyStyleCheesePizza extends Pizza {
    public NyStyleCheesePizza(){
        name="NY Style Sauce and Cheese Pizza";
        dough="Thin Crust Dough";
        sauce="Marinara Sauce";
    }
}

public class FactoryTest {

    @Test
    public void testFactory(){
        AbstractPizzaStore pizzaStore=new NYPizzaStore();
        pizzaStore.orderPizza("cheese");
    }
}

抽象工廠模式

提供一個接口，用於建立相關或依賴對象的家族，而不須要明確指定的具體類

/**
 * pizz原料
 *
 * @author Colin
 * @create 2018-04-23
 **/
public interface PizzaIngredientFactory {
    /**
     *
     * @return
     */
    public Dough createDough();

    /**
     *
     * @return
     */
    public Sauce createSauce();
}

/**
 * 紐約pizza原料
 *
 * @author Colin
 * @create 2018-04-23
 **/
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Dough createDough() {
        return null;
    }

    @Override
    public Sauce createSauce() {
        return null;
    }
}

總結

• 簡單工廠最大的優勢在於工廠類中包含了必要的邏輯判斷，根據客戶端的選擇條件動態的實例化相關的類，違反了開閉原則。
• 工廠方法模式把簡單工廠的內部邏輯判斷移到了客戶端代碼來進行。你想要加功能，原本改工廠類的，如今是修改客戶端。
• 抽象工廠，當你建立產品家族和想讓製造相關的產品集合起來時，能夠使用。

• 工廠方法，須要實例化的具體類中解耦，或者若是你不知道未來須要實例化哪些具體類時能夠使用。

  涉及原則

• 要依賴抽象，不要依賴具體類