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

一、概念

工厂方法模式：用来封装对象的创建。工厂方法模式（Factory Method Pattern）通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。这样，关于超类的代码和子类创建对象的代码之间就解耦了。
抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用来创建相关或依赖对象的家族，而不需要明确指定具体类。这样，产品创建的过程只会依赖于接口，而不关心具体的实现是什么，从而达到解耦的目的。
角色 - 工厂方法模式：
1、抽象工厂（Creator）：定义了一个抽象的工厂方法，让子类实现此方法制造产品。
2、具体工厂（ConcreteCreator）：实现抽象工厂方法，包含具体生产产品的实现代码，返回一个产品的实例。
3、抽象产品（Product）：定义一个抽象的产品，为了工厂中创建产品类型的匹配。
4、具体产品（ConcreteProduct）：实现抽象产品，包含各自产品的特色代码。
角色 - 抽象工厂模式：
1、抽象工厂（Creator）：一般是接口或抽象类，定义了一系列的产品家族。
2、具体工厂（ConcreteCreator）：实现抽象工厂方法，包含一系列产品家族的实现代码。
3、抽象产品（Product）：定义一个抽象的产品，为了工厂中创建产品类型的匹配。
4、具体产品（ConcreteProduct）：实现抽象产品，包含各自产品的特色代码。

二、Demo 实现 - 工厂方法模式

TOPIC：我们要定义一个披萨店，并允许个人或机构加盟，而且个人或机构可以根据当地不同的口味生产不同的披萨。

1、抽象工厂 - PizzaStore.java

public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println(pizza.name);
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    
    protected abstract Pizza createPizza(String type);
}

这里，我们定义了一个抽象工厂角色，并定义了一个抽象工厂方法。这样产品（Pizza）的实例化过程会交由抽象工厂的子类 —— 具体工厂去创建。

2、抽象产品 - Pizza.java

public abstract class Pizza {
    /**
     * 披萨的名字
     */
    protected String name;

    protected void bake() {
        System.out.println("烘烤25分钟...");
    }

    protected void cut() {
        System.out.println("把匹萨沿着对角线切开...");
    }

    protected void box() {
        System.out.println("包装用官方标准的盒子...");
    }
}

这里，我们定义了一个抽象产品角色，之所以把产品定义成抽象的，有两个原因：一是为了在具体工厂中生产的产品可以用统一的抽象父类来接收；二是为了让加盟商可以任意的扩展自己的产品。这种设计符合我们的设计原则 —— 面向接口（或抽象）编程，不面向实现编程。

3、具体产品

现在有加盟商要加盟我们的商店，他希望能够按照他们的地方特色，自定义他们要出售的披萨...那么，只要扩展 Pizza 类就可以了！

public class CheesePizza extends Pizza {
    public CheesePizza() {
        name = "这是一个奶酪披萨";
    }
    @Override
    protected void bake() {
        System.out.println("烘烤30分钟...");
    }
    @Override
    protected void cut() {
        System.out.println("把匹萨按四等分切开...");
    }
    @Override
    protected void box() {
        System.out.println("包装用奶酪披萨特制的盒子...");
    }
}

public class DurianPizza extends Pizza {
    public DurianPizza() {
        name = "这是一个榴莲披萨";
    }
    @Override
    protected void bake() {
        System.out.println("烘烤45分钟...");
    }
    @Override
    protected void cut() {
        System.out.println("把匹萨按三等分切开...");
    }
    @Override
    protected void box() {
        System.out.println("包装用榴莲披萨特制的盒子...");
    }
}

4、具体工厂 - PizzaFactory.java

public class PizzaFactory extends PizzaStore {
    
    @Override
    protected Pizza createPizza(String type) {
        switch (type) {
            case "cheese":
                return new CheesePizza();
            case "durian":
                return new DurianPizza();
            default:
                break;
        }
        return null;
    }
}

这里，我们定义了一个具体工厂角色，继承自抽象工厂，产品（Pizza）的具体实例化代码在这里实现。

5、测试

public class Test {

    public static void main(String[] args) {
        PizzaStore store = new PizzaFactory();
        store.orderPizza("cheese");
        store.orderPizza("durian");
    }
}

avatar

三、使用抽象工厂模式重构代码

1、抽象工厂 - AbstractFactory.java

public interface AbstractFactory {
    /**
     * @Description 奶酪披萨制造接口
     */
    Pizza createCheese();

    /**
     * @Description 榴莲披萨制造接口
     */
    Pizza createDurian();
}

这里，我们定义了一个抽象工厂角色，我们用接口定义了一系列的产品家族。

2、具体工厂

public class AFactory implements AbstractFactory {

    @Override
    public Pizza createCheese() {
        System.out.println("A工厂制造的奶酪披萨");
        return new CheesePizza();
    }

    @Override
    public Pizza createDurian() {
        System.out.println("A工厂制造的榴莲披萨");
        return new DurianPizza();
    }
}

public class BFactory implements AbstractFactory {

    @Override
    public Pizza createCheese() {
        System.out.println("B工厂制造的奶酪披萨");
        return new CheesePizza();
    }

    @Override
    public Pizza createDurian() {
        System.out.println("B工厂制造的榴莲披萨");
        return new DurianPizza();
    }
}

这是两个具体的工厂类，实现了抽象工厂接口，包含了一系列产品家族的实现代码。

3、抽象产品和具体产品

抽象产品和具体产品的代码和工厂方法模式一致，这里就不加赘述了，来看看抽象工厂的使用吧！

4、测试

public class PizzaStore {

    private AbstractFactory abstractFactory;

    public PizzaStore(AbstractFactory abstractFactory) {
        this.abstractFactory = abstractFactory;
    }

    public void prepare() {
        this.abstractFactory.createCheese();
        this.abstractFactory.createDurian();
    }
}

public class Test {

    public static void main(String[] args) {
        AbstractFactory abstractFactory = new AFactory();
        PizzaStore pizzaStore = new PizzaStore(abstractFactory);
        pizzaStore.prepare();
        AbstractFactory abstractFactory2 = new BFactory();
        PizzaStore pizzaStore2 = new PizzaStore(abstractFactory2);
        pizzaStore2.prepare();
    }
}

抽象工厂模式在使用时，利用对象组合和多态将不同的工厂实现类注入到代码中。这样，代码只会依赖接口，根本不关心具体实现是什么，以此达到解耦的目的。