Head First Design Patterns——工厂方法模式

我们现在要添加一个功用，那就是订购披萨，根据不同的地方特色来订购，例如，BJCheessPizza,BJPepoperPizza，LDChessPizza等种类，此时，我们可以将OrderPizza类中的createPizza（）方法定义为abstract类型，谁调用就实现这个方法，然后对应的种类就实现功能了
下面的是类图的表示形式：

当然，这是在上篇的基础上改的，如果没有了解的参照：

• 抱歉！会设计模式就是很牛——简单工厂模式（静态工厂）
  大家在学习的时候主要结合例子，原理才是核心，如果不太懂的话还是学习一下UML类图，相信对你会有很大的帮助。下面让我们来用代码实现：
• Pizza (将Pizza类定义为abstract，还有抽象 方法prepare())

public abstract  class Pizza {

    private String name;

    public abstract void prepare();

    public void bake() {
        System.out.println("baking;");
    }

    public void cut() {
        System.out.println("cuting;");
    }

    public void box() {
        System.out.println("boxing;");
    }

    public void setName(String name) {
        this.name = name;
    }
}

• BJChessPizza

public class BJChessPizza extends  Pizza{
    @Override
    public void prepare() {
        setName("北京奶酪披萨");
        System.out.println("北京奶酪披萨BjChessPizza 准备原材料");
    }
}

• BJPepperPizza

public class BJPepperPizza extends  Pizza{
    @Override
    public void prepare() {
        setName("BJPepperPizza");
        System.out.println("BJPepperPizza 准备原材料");
    }
}

• LDChessPizza

public class LDChessPizza extends  Pizza{
    @Override
    public void prepare() {
        setName("伦敦奶酪披萨");
        System.out.println("LDChessPizza 准备原材料");
    }
}

• LDPepperPizza

public class LDPepperPizza extends  Pizza{
    @Override
    public void prepare() {
        setName("LDPepperPizza");
        System.out.println("LDPepperPizza 准备原材料");
    }
}

• BJOrderPizza

public class BJOrderPizza extends OrderPizza2{

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("chess")){
            pizza = new BJChessPizza();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

• LDOrderPizza

public class LDOrderPizza extends OrderPizza2{

    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new LDChessPizza();
        }else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

• OrderPizza2 (这个类并不处理具体new的是哪个 对象，而是根据输入的类型，交给子类指定的OrderPizza来处理，只是负责调用)

public abstract class OrderPizza2 {

    //定义一个抽象方法，createPizza,让各个工厂子类自己实现
    abstract Pizza createPizza(String orderType);

    Pizza pizza;

    public OrderPizza2() {
        String orderType;
        do {
            orderType = getype();
            pizza = createPizza(orderType);//抽象方法，由工厂子类来完成

            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    //写一个方法，可以获取客户端希望订购的披萨种类
    private String getype(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input Pizza type:");
            String str = strin.readLine();
            return str;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
}

• PizzaStore

public class PizzaStore {
    public static void main(String[] args) {
        new BJOrderPizza();
    }
}

• 运行结果
  

总结：工厂方法模式就是按类型创建时，将每一个类型都交给他们自己的工厂来生产，然后再由用一个类来按照传入的类型来创建，具体的实现都交给他们的子类来完成，也可以用“工厂的工厂”来形容！