设计模式之简单工厂模式

简单工厂模式

一个简单的需求：

1. 披萨的种类很多(比如GreekPizz、CheesePizz 等)
2. 披萨的制作有prepare,bake, cut, box
3. 完成披萨店订购功能。

1.传统的方式来实现

UML类图

定义一个抽象类定义Pizza

public abstract class Pizza {
    // 名字
    protected String name;

    // 准备原材料，因为每个披萨的原材料不同所以是抽象的
    public abstract void prepare();

    // 烘烤
    public void bake() {
        System.out.println(name + "披萨进行烘烤");
    }

    // 切割
    public void cut() {
        System.out.println(name + "披萨进行切割");
    }

    // 打包
    public void box() {
        System.out.println(name + "披萨进行打包");
    }

    public String getName() {
        return name;
    }

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

一个具体的Pizza类型

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

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

客户端

// 相当于一个客户端
public class PizzaStore {

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

Pizza构造器   可以理解为具体生产的店铺

public class OrderPizza {

    // 构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType; // 订购披萨的类型
        do {
            orderType = this.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.bake();
        }while (true);
    }

    // 获取客户需要订购的披萨种类
    private String getType() {
        Scanner sc = new Scanner(System.in);
        System.out.println("您订购的披萨种类：");
        return sc.nextLine();
    }
}

• 优点：好理解，操作简单
• 缺点：违反了设计模式中的ocp原则,当增加新的Pizza种类时，首先需要增加一个新的Pizza类来继承Pizza类，其次，要修改orderPizza中的代码，试想在实际生活中可能不止一个生产Pizza的店铺，比如连锁店，如果每个orderPizza都需要更改则很繁琐且易出错。
• 改进思路：将创建Pizza对象封装到一个类中，在添加新的Pizza时只需要修改该类即可。

简单工厂模式

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2. 简单工程模式：定义了一个创建对象的类，有这个类来封装实例化对象的行为（代码）。

UML类图：

代码：

添加一个SimpleFactory类
包含一个方法，根据参数传进来的类型创建对应的Pizza

// 简单工厂类
public class SimpleFactory {

    // 根据orderType返回对应的Pizza实例对象
    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("奶酪披萨");
        }

        return pizza;
    }
}

更改orderPizza类
在orderPizza类内部不在进行具体的判断类型和构造Pizza对象
通过将类型参数传入SimpleFactory类中的createPizza方法返回一个创建好的Pizza对象。

public class OrderPizza {

    // 构造器
    public OrderPizza(SimpleFactory simpleFactory) {
        setSimpleFactory(simpleFactory);
    }

    // 定义一个简单工厂对象
    SimpleFactory simpleFactory;
    Pizza pizza = null;

    public void setSimpleFactory(SimpleFactory simpleFactory) {
        String orderType = "";

        this.simpleFactory = simpleFactory;

        do {
            orderType = this.getType();
            pizza = this.simpleFactory.createPizza(orderType);

            // 输出
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.bake();
            } else {
                System.out.println("不好意思，目前还没有您订购的Pizza种类");
                break;
            }
        }while (true);
    }

    // 获取客户需要订购的披萨种类
    private String getType() {
        Scanner sc = new Scanner(System.in);
        System.out.println("您订购的披萨种类：");
        return sc.nextLine();
    }
}

相应的客户端方法也需要发生改变。

// 相当于一个客户端
public class PizzaStore {

    public static void main(String[] args) {
//        new OrderPizza();
        //使用简单工厂模式
        new OrderPizza(new SimpleFactory());
        System.out.println("----退出程序----");
    }
}

• 改进的优点：如果此时需要增加一个新的Pizza类型，只需要增加一个继承Pizza的具体类，并且更改工厂类SimpleFactory中createPizza方法即可，不需要更改所有的orderPizza类。

分析

• 传统的方法流程：客户端（PizzaStore） --> 店铺（orderPizza）–> 店铺负责判断类型并生产。
• 简单工程模式： 客户端（PizzaStore）–> 店铺（orderPizza） --> 工厂（SimpleFactory） – > 此时店铺不在判断和生产，只是将需要的类型发送给工厂由工厂去生产。
• 如果需要添加新的Pizza类型只需要修改工厂就可以了，因为工厂只有一个但是店铺有很多个。

改为静态的工厂类方法

可以将SimpleFactory中的方法createPizza变为静态的这样调用起来会更加方便

更改SimpleFactory类

// 简单工厂类
public class SimpleFactory {

    // 根据orderType返回对应的Pizza实例对象
    public static 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("奶酪披萨");
        }

        return pizza;
    }
}

更改orderPizza方法

public class OrderPizza {

    private Pizza pizza = null;
    private String orderType = "";
    // 构造器
    public OrderPizza() {
        do {
            orderType = this.getType();
            pizza = SimpleFactory.createPizza(orderType);

            // 输出
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.bake();
            } else {
                System.out.println("不好意思，目前还没有您订购的Pizza种类");
                break;
            }
        }while (true);
    }


    // 获取客户需要订购的披萨种类
    private String getType() {
        Scanner sc = new Scanner(System.in);
        System.out.println("您订购的披萨种类：");
        return sc.nextLine();
    }
}

更改客户端类

// 相当于一个客户端
public class PizzaStore {

    public static void main(String[] args) {
//        new OrderPizza();
        //使用简单工厂模式
//        new OrderPizza(new SimpleFactory());
//        System.out.println("----退出程序----");
        new OrderPizza();
    }
}