工厂模式

简单工厂模式

简单工厂模式其实不是一个模式，反而比较像一个编程习惯。

/**
 * 披萨类
 *
 * @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;
    }
}

总结

• 简单工厂最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态的实例化相关的类，违反了开闭原则。
• 工厂方法模式把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，本来改工厂类的，现在是修改客户端。
• 抽象工厂，当你创建产品家族和想让制造相关的产品集合起来时，可以使用。
• 工厂方法，需要实例化的具体类中解耦，或者如果你不知道将来需要实例化哪些具体类时可以使用。

涉及原则

• 要依赖抽象，不要依赖具体类