第一节：不使用设计模式的传统方式

一、提出需求

　　分析一个关于生产披萨的项目：要便于披萨种类的扩展，要便于维护。

　　（1）披萨的种类很多（比如：GreekPizza、CheesePizza 等）

　　（2）披萨的制作有 prepare，bake，cut，box

　　（3）完成披萨店订购功能。

二、使用传统的方式来完成

　　思路分析：可以得到，将披萨做成一个抽象类，里面声明所有披萨都需要的功能，然后根据需要来继承该类，再创建一个订购类，可以根据用户输入的披萨名称来生产不同种类的披萨。

　　UML 类图：

　　

　　Demo：不使用设计模式

　　Pizza 相关类

/**
 * 将 pizza 类做成抽象类
 */
public abstract class Pizza {
    //名字
    protected String name;

    //准备原材料, 不同的披萨不一样，因此，我们做成抽象方法
    public abstract void prepare();

    //烘焙
    public void bake() {
        System.out.println(name + " baking;");
    }

    //切割
    public void cut() {
        System.out.println(name + " cutting;");
    }

    //打包
    public void box() {
        System.out.println(name + " boxing;");
    }

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

}

public class GreekPizza extends Pizza{
    @Override
    public void prepare() {
        System.out.println(" 给希腊披萨 准备原材料 ");
    }
}

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println(" 给制作奶酪披萨 准备原材料 ");
    }
}

订购披萨

public class OrderPizza {

    //构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; //订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else {
                System.out.println("此类披萨还未上架");
                break;
            }
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }

    //声明一个方法，可以获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza 种类：");
            String str = bufferedReader.readLine();
            return str;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

测试类：

public class PizzaStore {

    public static void main(String[] args) {
        new OrderPizza();
    }
}

 　　效果：

          

　　

　　此时，我们需要另外上架一个新的 PepperPizza 披萨，对代码做出对应的修改。

　　 创建一个 PepperPizza 类：

public class PepperPizza extends Pizza {
    @Override
    public void prepare() {
        // TODO Auto-generated method stub
        System.out.println(" 给胡椒披萨准备原材料 ");
    }
}

　　对订购披萨类进行修改：

public OrderPizza() {
        Pizza pizza = null;
        String orderType; //订购披萨的类型
        do {
            orderType = getType();
            if (orderType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            } else if (orderType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName("奶酪披萨");
            } else if (orderType.equals("pepper")) {
                pizza = new PepperPizza();
                pizza.setName("胡椒披萨");
            } else {
                System.out.println("此类披萨还未上架");
                break;
            }
            //输出披萨制作过程
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();

        } while (true);
    }

 　　类图：

　　　　

 三、传统的方式的优缺点

　　1、优点是比较好理解，简单易操作。

　　2、缺点是违反了设计模式的 OCP 原则，即对扩展开发，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码。

　　3、比如这时要新增一个 Pizza 的种类（Pepper披萨），需要做如下修改：

　　　　① 增加一个对应的 PepperPizza类；

　　　　② 凡是订购 Pizza 的代码都需要修改；（可能有一处或者多处都使用）

　　　　

　　4、改进的思路分析

　　　　分析：修改代码可以接受，但是如果我们在其他的地方也有创建 Pizza的代码，就意味着，也需要修改，而创建 Pizza 的代码，往往有多处。

　　　　思路：把创建 Pizza 对象封装到一个类中，这样我们有新的 Pizza 种类时，只需要修改该类即可。其他有创建到Pizza对象的代码就不需要修改了。