常用设计模式——工厂模式

前言：曾经以为工厂模式很简单，其实不然，工厂模式有3种模式，下面分别阐述：

简单工厂

概念

创建一个工厂对象，来封装创建对象的过程

示例

/**
 * 生产鸭对象的工厂
 */
public class DurkFactory {

    public Durk getDuck() {
        return new Durk();
    }

}

工厂方法模式

概念

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

• 当只有一个具体创建者时有什么优点：尽管只有一个具体创建者，工厂方法模式依然很有用。它帮我们把产品的"实现"从使用中"解耦"(抽象工厂含有一些产品的操作)。 如果增加产品或者改变产品的实现，Creator并不会受到影响。

示例

/**
 * 比萨 制作店
 * （1）涉及到工厂模式、模板方法模式
 * @author huangy on 2019-05-19
 */
public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;

        // 创建pizza的代码和其他固定代码分离开来
        pizza = createPizza(type);

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

        return pizza;
    }

    // 该方法负责创建对象，如同一个工厂（抽象工厂，具体实现由子类负责）
    public abstract Pizza createPizza(String type);
}

/**
 * 工厂子类
 * @author huangy on 2019-05-19
 */
public class NYPizzaStore extends PizzaStore {

    @Override
    public Pizza createPizza(String type) {
        if (type.equals("Cheese")) {
            return new NYStyleCheesePizza();
        }

        return null;
    }
}

/**
 * 比萨
 * @author huangy on 2019-05-19
 */
public interface Pizza {

    void prepare();

    void bake();

    void cut();

    void box();
}

/**
 * 纽约风味披萨
 * @author huangy on 2019-05-19
 */
public class NYStyleCheesePizza implements Pizza {

    @Override
    public void prepare() {

    }

    @Override
    public void bake() {

    }

    @Override
    public void box() {

    }

    @Override
    public void cut() {

    }
}

优点

• 如果有很多个客户端都需要生成某个对象，如果生成某个对象的代码有变动，那么这些客户端的代码都要改变，因此，把产生对象实例的代码封装起来。
• 可以帮助我们针对接口变成，而不是针对具体实现类。

抽象工厂模式

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

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

区别

• 工厂方法模式是通过子类生成一个对象

• 抽象工厂模式是通过子类生成一组对象

示例

/**
 * 比萨原料 抽象工厂
 * 负责生产产品族，在这里是原料
 * @author huangy on 2019-05-19
 */
public abstract class PizzaIngredientFactory {

    /**
     * 生成 面团
     */
    public Dough createDough() {

        Dough dough;

        System.out.println("before createDough one");

        System.out.println("before createDough two");

        dough = createDoughSub();

        System.out.println("before createDough three");

        return dough;
    }

    /**
     * 由具体子类 决定生成怎样的面团
     */
    abstract Dough createDoughSub();

    /**
     * 生产酱料
     */
    abstract Sauce createSauce();

    /**
     * 生成奶酪
     */
    abstract Cheese createCheese();
}

/**
 * 抽象工厂子类（具体工厂），由该子类负责生成哪一种产品
 * @author huangy on 2019-05-19
 */
public class NYPizzaIngredientFactory extends PizzaIngredientFactory {

    @Override
    Dough createDoughSub() {
        return new HotDough();
    }

    @Override
    public Sauce createSauce() {
        return null;
    }

    @Override
    public Cheese createCheese() {
        return null;
    }
}

/**
 * 奶酪比萨（这里相当于客户端）
 * @author huangy on 2019-05-19
 */
public class CheesePizza extends Pizza {

    PizzaIngredientFactory pizzaIngredientFactory;

    public CheesePizza(PizzaIngredientFactory pizzaIngredientFactory) {
        this.pizzaIngredientFactory = pizzaIngredientFactory;
    }

    @Override
    void prepare() {
        // 使用原料抽象工厂来生产原料
        dough = pizzaIngredientFactory.createDough();
        sauce = pizzaIngredientFactory.createSauce();
        cheese = pizzaIngredientFactory.createCheese();
    }
}