设计模式之简单工厂模式

看一个具体的需求

看一个披萨的项目：要便于披萨种类的扩展，要便于维护

1) 披萨的种类很多 ( 比如 GreekPizz 、 CheesePizz 等 )

2) 披萨的制作有 prepare ， bake, cut, box

3) 完成披萨店订购功能。

使用传统的方式来完成

0）传统模式的UML图

1）写一个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;
    }
}

2）写一个GreekPizza类继承Pizza抽象类

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("制作希腊披萨");
    }
}

3）写一个CheesePizza类继承Pizza抽象类

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

4）写一个OrderPizza的类用于订购披萨

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{
                break;
            }
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }
    private String getType() {
        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 "";
        }
    }
}

5）写一个PizzaStore类，相当于一个客户端

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

6）运行结果

input pizza type:
greek
制作希腊披萨
希腊披萨 baking;
希腊披萨 cutting;
希腊披萨 boxing;
input pizza type:
cheese
制作奶酪披萨
奶酪披萨 baking;
奶酪披萨 cutting;
奶酪披萨 boxing;
input pizza type:
ggg

总结：传统的方式的优缺点

1）优点是容易理解，简单易操作

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

3）比如要增加一个新的Pizza种类（Pepper披萨），需要新增一个PepperPizza类，修改OrderPizza类，新增else if，如果项目做大OrderPizza类就不止一个（会有OrderPizza1、OrderPizza2、OrderPizza3...），到时候要修改OrderPizza类的代码量就非常大。

4）改进方法，可以使用简单工厂模式

简单工厂模式

1) 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一 个工厂对象决定创建出哪一种产品类的实例

2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)

3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式 

使用简单工程模式的方式来完成

0）简单工厂模式的UML图

1）创建一个简单工厂类SimpleFactory

public class SimpleFactory {

    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        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("胡椒披萨");
        }
        return pizza;
    }
}

2）修改OrderPizza类，将创建Pizza对象代码注释，把创建的代码抽取到SimpleFactory类

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{
//                break;
//            }
//            pizza.prepare();
//            pizza.bake();
//            pizza.cut();
//            pizza.box();
//        }while (true);
//    }
    SimpleFactory simpleFactory;
    Pizza pizza = null;
    //构造器，聚合关系
    public OrderPizza(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory){
        String orderType = "";//用户输入

        this.simpleFactory = simpleFactory;//设置简单工厂对象
        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);
            if (pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }
    private String getType() {
        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 "";
        }
    }
}

3）修改PizzaStore类

public class PizzaStore {
    public static void main(String[] args) {
//        new OrderPizza();
        new OrderPizza(new SimpleFactory());
        System.out.println("退出程序");
    }
}

4）运行结果

input pizza type:
cheese
使用简单工厂模式
制作奶酪披萨
奶酪披萨 baking;
奶酪披萨 cutting;
奶酪披萨 boxing;
input pizza type:
pepper
使用简单工厂模式
制作胡椒披萨
胡椒披萨 baking;
胡椒披萨 cutting;
胡椒披萨 boxing;
input pizza type:
China
使用简单工厂模式
订购披萨失败
退出程序

PS：简单工厂模式也叫静态工厂模式

 //简单工厂模式也叫静态工厂模式
    public static Pizza createPizza2(String orderType) {
        Pizza pizza = null;
        System.out.println("使用简单工厂模式");
        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("胡椒披萨");
        }
        return pizza;
    }

public class OrderPizza2 {

    SimpleFactory simpleFactory;
    Pizza pizza = null;
    String orderType = "";//用户输入
    //构造器，聚合关系
    public OrderPizza2() {
        do {
            orderType = getType();
            pizza = SimpleFactory.createPizza2(orderType);
            if (pizza!=null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("订购披萨失败");
                break;
            }
        }while (true);
    }
    private String getType() {
        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 "";
        }
    }
}

public static void main(String[] args) {
//        new OrderPizza();
//        new OrderPizza(new SimpleFactory());
//        System.out.println("退出程序");
        new OrderPizza2();
    }