【设计模式】23种设计模式之工厂模式

工厂模式

​ 在现实生活中社会分工越来越细，越来越专业化。各种产品有专门的工厂生产，彻底告别了自给自足的小农经济时代，这大大缩短了产品的生产周期，提高了生产效率。同样，在软件开发中能否做到软件对象的生产和使用相分离呢？能否在满足“开闭原则”的前提下，客户随意增删或改变对软件相关对象的使用呢？这就是本节要讨论的问题。

定义

工厂模式定义了一个创建对象的接口（抽象基类），但由子类决定要示例化的类是哪一个。工厂方法模式让类把实例化推迟到子类。

UML类图

使用场景

1.客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。

2.创建产品的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。

3.客户不关心创建产品的细节，只关心产品的品牌。

示例

以下是工厂类：

Pizza工厂基类

/**
 * 产品工厂基类
 */
public abstract class PizzaFactory {

    /**
     * 根据Type创建不同的产品
     *
     * @param type 产品类型
     * @return
     */
    public Pizza createProduct(String type) {
        Pizza pizza;
        // 生产Pizza产品
        pizza = createPizza(type);
        // 对Pizza产品做一些操作
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        // 返回生产的产品
        return pizza;
    }

    protected abstract Pizza createPizza(String type);
}

纽约Pizza工厂

/**
 * 纽约Pizza工厂
 */
public class NYPizzaFactory extends PizzaFactory {
    @Override
    protected Pizza createPizza(String type) {
        Pizza pizza = null;
        switch (type) {
            case "Cheese":
                pizza = new NYStlyeCheesePizza();
                break;
            case "Clam":
                pizza = new NYStyleClamPizza();
                break;
        }
        return pizza;
    }
}

芝加哥Pizza工厂

/**
 * 芝加哥Pizza工厂
 */
public class ChicagoPizzaFactory extends PizzaFactory {

    @Override
    protected Pizza createPizza(String type) {
        Pizza pizza= null;
        switch (type){
            case "Cheese":
                pizza = new ChicagoCheesePizza();
                break;
            case "Clam":
                pizza = new ChicagoClamPizza();
                break;
        }
        return pizza;
    }
}

以下是产品类：

Pizza基类

/**
 * 披萨基类
 */
public class Pizza {
    protected String name; // 名称
    protected String dough; // 面团
    protected String sauce; // 酱料
    protected List<String> topping = new ArrayList(); // 配料

    public void prepare() {
        // 准备
        System.out.println("正在准备的Pizza：" + name);
    }

    public void bake() {
        // 烘培
        System.out.println("烘培需要30分钟..");
    }

    public void cut() {
        // 切片
        System.out.println("正在切片...");
    }

    public void box() {
        // 装盒
        System.out.println("Pizza装进方盒..");
    }

    public String getName() {
        return name;
    }
}

纽约奶酪Pizza

/**
 * 纽约奶酪Pizza
 */
public class NYStlyeCheesePizza extends Pizza {

    public NYStlyeCheesePizza(){
        name = "纽约奶酪Pizza";
        dough = "纽约面团";
        sauce  = "纽约酱料";
        topping.add("纽约佐料");
    }

    @Override
    public void cut(){
        System.out.println("纽约奶酪Pizza要切成圆形...");
    }
}

纽约蛤蜊Pizza

/**
 * 纽约蛤蜊Pizza
 */
public class NYStyleClamPizza extends Pizza {

    public NYStyleClamPizza(){
        name = "纽约蛤蜊Pizza";
        dough = "纽约面团";
        sauce  = "纽约酱料";
        topping.add("纽约佐料");
    }

    @Override
    public void cut(){
        System.out.println("纽约蛤蜊Pizza要切成圆形...");
    }
}

芝加哥奶酪Pizza

/**
 * 芝加哥奶酪Pizza
 */
public class ChicagoCheesePizza extends Pizza {
    public ChicagoCheesePizza(){
        name = "芝加哥奶酪Pizza";
        dough = "芝加哥面团";
        sauce  = "芝加哥酱料";
        topping.add("芝加哥佐料");
    }

    @Override
    public void cut(){
        System.out.println("芝加哥奶酪Pizza要切成方形...");
    }
}

芝加哥蛤蜊Pizza

/**
 * 芝加哥蛤蜊Pizza
 */
public class ChicagoClamPizza extends Pizza {

    public ChicagoClamPizza(){
        name = "芝加哥蛤蜊Pizza";
        dough = "芝加哥面团";
        sauce  = "芝加哥酱料";
        topping.add("芝加哥佐料");
    }

    @Override
    public void cut(){
        System.out.println("芝加哥蛤蜊Pizza要切成方形...");
    }
}

测试：

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        // 用纽约Pizza工厂生产一个纽约蛤蜊Pizza
        NYPizzaFactory nyPizzaFactory = new NYPizzaFactory();
        Pizza nyClamPizza = nyPizzaFactory.createProduct("Clam");

        // 用芝加哥Pizza工厂生产一个芝加哥奶酪Pizza
        ChicagoPizzaFactory chicagoPizzaFactory = new ChicagoPizzaFactory();
        Pizza chicagoCheesePizza = chicagoPizzaFactory.createProduct("Cheese");
    }
}

结果：

正在准备的Pizza：纽约蛤蜊Pizza
烘培需要30分钟..
纽约蛤蜊Pizza要切成圆形...
Pizza装进方盒..
正在准备的Pizza：芝加哥奶酪Pizza
烘培需要30分钟..
芝加哥奶酪Pizza要切成方形...
Pizza装进方盒..

优缺点

优点：

1.用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

2.灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

3.典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点：

1.类的个数容易过多，增加复杂度。

2.增加了系统的抽象性和理解难度。

3.抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

工作中的应用

敬请期待

设计原则工具箱

1.找出应用中可能需要变化的部分，把它们独立出来，不要和那些不需要变化的代码混合在一起

2.针对接口（超类型）编程而不是针对具体的实现编程

3.多用组合少用继承

4.为了交互对象之间的松耦合设计而努力

5.类应该对扩展开放，对修改关闭

6.依赖抽象，不要依赖具体类。（即不要让高层组件依赖低层组件，而且不管高层组件还是低层组件都应该依赖于抽象）