设计模式笔记_四_工厂模式

[TOC]

工厂模式

工厂方法模式
抽象工厂模式

工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样，客户程序中关于超类的代码就和子类对象创建代码解耦了。

所有工厂模式都用来封装对象的创建。

依赖倒置原则

依赖倒置：要依赖抽象，不要依赖具体类。

不能让高层组件依赖低层组件，而且，不管高层组件或低层组件，两者都应该依赖于抽象。

在依赖导致原则中，倒置指的是和一般OO设计的思考方式完全相反。

技巧

避免在OO设计中违反依赖倒置原则的技巧：

变量不可以持有具体类的引用。如果使用new，就会持有具体类的引用。可以改用工厂来避开这样的做法。
不要让类派生自具体类。如果派生自具体类，就会依赖具体类。应该派生自一个抽象（接口或抽象类）。
不要覆盖基类中已实现的方法。如果覆盖基类已实现的方法，那么基类就不是一个真正适合被继承的抽象。基类中以实现的方法，应该由所有子类共享。

引言

我们不应该针对实现编程，但是当我们每次使用new时，就会想到“具体”。使用new时，的确是在实例化一个具体类，所以用的确实是实现，而不是接口。我们知道，代码绑定具体类会导致代码更脆弱，更缺乏弹性。

当看到这样的代码，一旦有变化或扩展，就必须重新打开这段代码进行检查和修改。通常这样修改过的代码将造成部分系统更难维护和更新，而且也更容易犯错。

针对接口编程，可以隔离掉以后系统可能发生的一大堆改变。因为，如果代码是针对接口而写，那么通过多态，它可以与任何新类实现该接口。

当代码使用大量具体类时，一旦进入新的具体类，就必须改变代码。也就是说，你的代码并非“对修改关闭”。

解决上述问题，就需要“找出会变的方面，把它们从不变的部分分离出来”。

简单工厂方法

算不上设计模式（依据《Head First 设计模式》）
简单工厂模式属于创建型模式
又叫做静态工厂方法
简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类

角色及职责

工厂（Creator）角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品（Product）角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

优缺点

优点

明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点

违反了高内聚责任分配原则。如果添加新类，则需要改变工厂类。

示例

参考案例中披萨工厂简单工厂阶段。

工厂方法模式

定义

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

工厂方法模式(Factory Method Pattern)通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

工厂方法模式能够封装具体类型的实例化。抽象的Creator提供了一个创建对象的方法的接口，也成为“工厂方法”。在抽象的Creator中，任何其他实现的方法，都可能使用到这个工厂方法所制造出来的产品，但只有子类真正实现这个工厂方法并创建产品。

工厂方法模式不过是，通过子类来创建对象。

工厂方法：用来创建对象的方法。

优点

工厂模式帮助我们将产品的实现从使用中解耦。如果增加产品或者改变产品的实现，Creator并不会受到影响(因为Creator与任何ConcreteProduct之间都不是紧耦合)。
创建对象的代码集中在一个对象或方法中，可以避免代码中的重复，并且更方便以后的维护
客户在实例化对象时，只会依赖于接口，而不是具体类
可以帮助我们针对接口编程，而不是针对实现编程。这让代码更具有弹性，可以应对未来的扩展
封装起创建对象的代码，就可以对抽象编码，将客户代码和实现代码解耦

组成元素

创建者(Creator)类
产品类

平行的类层级

抽象工厂模式

定义

抽象工厂模式 提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道实际产出的具体产品是什么。这样一来，客户就从具体的产品中被解耦。

类图

比较工厂方法模式和抽象工厂模式

工厂方法模式潜伏在抽象工厂模式中。抽象工厂的方法经常以工厂方法的方式实现。抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法。

工厂方法模式和抽象工厂模式，都用来负责创建对象，都可以把应用程序从特定实现中解耦，只是做法不同：

工厂方法模式：
- 使用的是类，利用的方法是继承。
- 整个工厂方法，只不过是通过子类来创建对象。用这种做法，客户只需要知道他们所使用的抽象类型就可以了，而由子类来负责决定具体类型。换句话说，工厂方法模式只负责将客户从具体类型中解耦。
- 可以把客户代码从需要实例化的具体类中解耦。
- 相对简单，只要继承为子类，并实现工厂方法即可。
抽象工厂模式：
- 通过对象的组合实现解耦。
- 提供一个用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被产生的方法。要想使用这个工厂，必须先实例化它，然后将它传入一些针对抽象类型所写的代码中。所以，和工厂方法一样，抽象工厂可以吧客户从所使用的实际具体产品中解耦。
- 此外，还可以把一群相关的产品集合起来。但是，如果需要扩展这组产品，需要修改接口。
- 当需要创建产品家族，并想让制造的相关产品集合起来时使用。

类图对比

以披萨店为例

工厂方法模式

总结

工具

基础

抽象
封装
多态
继承

原则

多用组合，少用继承
针对接口编程，不针对实现编程
为交互对象之间的松耦合设计而努力
类应该对扩展开放，对修改关闭
依赖抽象，不要依赖具体

设计模式

抽象工厂模式
工厂方法模式

要点

所有的工厂都是用来封装对象的创建
简单工厂，虽然不是真正的设计模式，但扔不失为一个简单的方法，可以将客户程序从具体类解耦
工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象
抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中
所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合
工厂方法允许类将实例化延迟到子类进行
抽象工厂创建相关的对象家族，而不需要依赖他们的具体类
依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象
工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程

案例

披萨工厂

简单工厂阶段

识别变化的方面

假如你有一个披萨店，你的代码可能这样写：

如果需要更多的披萨类型，则需要增加代码，来决定适合的比萨类型，然后再制造这个披萨：

如果，此时，披萨的类型发生了很多变化：

很明显，实例化某些具体类，将使orderPizza()出问题，而且也无法让orderPizza()对修改关闭。但是，我们已经知道了那些地方会改变，那些地方不会，接下来就是使用封装的时候了。

封装变化的部分

建立简单的工厂

定义一个类，为所有比萨封装创建对象的代码：

几个疑惑：

重做PizzaStore类

使用披萨工厂来，修改客户代码：

简单工厂阶段总结

简单工厂其实不是一个设计模式，反而像是一种编程习惯

使用简单工厂方法，实现的披萨店类图：

在设计模式中，“实现一个接口”并“不一定”表示“写一个类，并利用implements关键词来实现某个接口”。“实现一个接口”泛指实现某个超类型(可以是类或接口)的某个方法。

工厂方法模式阶段

加盟披萨店

一种做法

利用SimplePizzaFactory，写出三种不同的工厂，分别是NYPizzaFactory、ChicagoPizzaFactory、CaliforniaPizzaFactory。

然后，变成这个样子：

加盟店采用你的工厂创建披萨，但在其他部分，他们想采用自创的流程：烘烤的做法有差异、不要切片等。

稍早的SimplePizzaFactory，制作披萨的代码绑在PizzaStore内，这么做没有弹性，导致上述需求不能满足。

另一种方法

给披萨店使用框架。有个做法可让披萨活动限制在PizzaStore类（之所以成为加盟店，必须要满足的），又同时能让加盟店可以自由地制作该区域的风味披萨。

所要做的事就是，把createPizza()方法放回PizzaStore内，不过要把它设置为抽象方法，最后为每个区域风味创建一个PizzaStore的子类。

PizzaStore超类

现在有了PizzaStore超类，让每个区域类型9（NYPizzaStore、ChicagoPizzaStore、CaliforniaPizzaStore）都继承这个PizzaStore，每个子类各自决定如何制造披萨。

允许子类做决定

我们已经知道：

PizzaStore已经有一个不错的订单系统，由orderPizza()方法负责处理订单，你希望所有加盟店都可以使用这个完善的系统
还需要允许加盟店之间制作披萨的差异，让createPizza()能够对这些变化来负责创建正确种类的披萨。

我们的做法是：让PizzaStore的各个子类负责定义自己的createPizza()方法。我们会得到一些PizzaStore具体的子类，每个子类都有自己的披萨变体，而仍然适合PizzaStore框架，并使用orderPizza()方法。

开一家披萨店吧

这是一家纽约风味的披萨店：

声明一个工厂方法

原本由一个对象负责所有具体类的实例化，现在通过对PizzaStore做一些小转变，变成由一群子类来负责实例化：

订购披萨

根据订单生产披萨

代码

Pizza

import java.util.ArrayList;

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨抽象超类
 */
public abstract class Pizza {
    String name;
    String dough;
    String sauce;
    ArrayList toppings = new ArrayList();

    void prepare() {
        System.out.println("Preparing " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding toppings: ");        
        for (int i=0; i < toppings.size(); ++i) {
            System.out.println("   " + toppings.get(i));
        }
    }

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }

    void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }

    public String getName() {
        return name;
    }
}

PizzaStore

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 工厂类
 */
public abstract class PizzaStore {
    public Pizza orderPizza(String type) {
        Pizza pizza;

        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    abstract Pizza createPizza(String type);
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 芝加哥披萨店
 */
public class ChicagoPizzaStore extends PizzaStore {
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new ChicagoStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new ChicagoStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new ChicagoStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new ChicagoStylePepperoniPizza();
        } else return null;
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class ChicagoStyleCheesePizza extends Pizza {

    public ChicagoStyleCheesePizza() { 
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
    }

    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class ChicagoStyleClamPizza extends Pizza {
    public ChicagoStyleClamPizza() {
        name = "Chicago Style Clam Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Frozen Clams from Chesapeake Bay");
    }

    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class ChicagoStylePepperoniPizza extends Pizza {
    public ChicagoStylePepperoniPizza() {
        name = "Chicago Style Pepperoni Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Black Olives");
        toppings.add("Spinach");
        toppings.add("Eggplant");
        toppings.add("Sliced Pepperoni");
    }

    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class ChicagoStyleVeggiePizza extends Pizza {
    public ChicagoStyleVeggiePizza() {
        name = "Chicago Deep Dish Veggie Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
        toppings.add("Black Olives");
        toppings.add("Spinach");
        toppings.add("Eggplant");
    }

    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 纽约披萨店
 */
public class NYPizzaStore extends PizzaStore {
    Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new NYStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else return null;
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class NYStyleCheesePizza extends Pizza {
    public NYStyleCheesePizza() {
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class NYStyleClamPizza extends Pizza {

    public NYStyleClamPizza() {
        name = "NY Style Clam Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Fresh Clams from Long Island Sound");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class NYStylePepperoniPizza extends Pizza {

    public NYStylePepperoniPizza() {
        name = "NY Style Pepperoni Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Sliced Pepperoni");
        toppings.add("Garlic");
        toppings.add("Onion");
        toppings.add("Mushrooms");
        toppings.add("Red Pepper");
    }
}

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 披萨具体类
 */
public class NYStyleVeggiePizza extends Pizza {

    public NYStyleVeggiePizza() {
        name = "NY Style Veggie Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
        toppings.add("Garlic");
        toppings.add("Onion");
        toppings.add("Mushrooms");
        toppings.add("Red Pepper");
    }
}

PizzaTestDrive

/**
 * 设计模式 - 工厂模式
 * PizzaStore
 * 测试类
 */
public class PizzaTestDrive {
    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}

输出

Preparing NY Style Sauce and Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings:
   Grated Reggiano Cheese
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box
Ethan ordered a NY Style Sauce and Cheese Pizza

Preparing Chicago Style Deep Dish Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings:
   Shredded Mozzarella Cheese
Bake for 25 minutes at 350
Cutting the pizza into square slices
Place pizza in official PizzaStore box
Joel ordered a Chicago Style Deep Dish Cheese Pizza

小结

实际应用中，应该把披萨类型的类型从String改为静态变量或者enum类型。

抽象工厂模式阶段

原料有了新需求

后来，披萨原料又有了新的需求...

我们需要建立原料工厂，来保证披萨的质量。可是，名称相同的原料，不同的地方，也是不一样了...

每个区域，对相同原料，有不同实现。

原料家族

建造原料工厂

为每个区域建造一个工厂。首先，为原料工厂定义一个接口，负责创建所有的原料。

/**
 * 设计模式 - 抽象工厂模式
 * 原料工厂接口
 */
public interface PizzaIngredientFactory {
    // 在接口中，每个原料都有一个对应的方法创建该原料

    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
}

创建纽约原料工厂

重做披萨基类

重做披萨实现类

重新设计披萨店

究竟做了什么...

现在的订单完成过程

首先需要一个纽约披萨店

PizzaStore nyPizzaStore = new NYPizzaStore();

现在已经有一个披萨店了，可以接受订单：
```
nyPizzaStore.orderPizza("cheese");
```
orderPizza()方法首先调用createPizza()方法：
```
Pizza pizza = createPizza("cheese");
```

当createPizza()方法被调用时，也就可是设计原料工厂了

Pizza pizza = new CheesePizza(nyIngredientFactory);    // 选择原料工厂，接着在PizzaStore中实例化，然后将它传进每个披萨的构造器中

接下来需要准备披萨。一旦调用prepare()方法，工厂将被要求准备原料:

void prepare() {
    dough = factory.createDough();
      sauce = factory.createSauce();
      cheese = facotry.createCheese();
}

最后，得到了准备好的披萨，orderPizza()就会接着烘焙、切片、装盒。

类图

上一页Design Pattern 下一页设计模式笔记_六_命令模式

最后更新于5年前

这有帮助吗？