1. 抽象工厂模式的定义

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道实际产出的具体产品是什么。这样，客户就从具体的产品中被解耦。

2. 抽象工厂模式的类图

3. 抽象工厂模式的作用

客户是通过具体工厂获取产品，客户并不关心产品的具体类型，这样客户就可以从具体的产品中解耦。

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

这个遵循依赖倒置原则，要依赖抽象，不要依赖具体类。这个原则说明类：不能让高层组件依赖低层组件，而且，不管高层或底层组件，都应该依赖于抽象。

4. 抽象工厂模式的实现

需求：披萨总公司以配方和原料的方式提供给加盟店，总公司需要提供不同风格的原料，所有需要不同风格的工厂。

/**
 * 抽象的披萨原料工厂，相当于抽象工厂模式中的抽象工厂
 */
public interface PizzaIngredientFactory {
    Dough createDough();

    Cheese createCheese();
}

/**
 * 中国披萨原料工厂，相当于抽象工厂模式中的具体工厂
 */
public class ChinesePizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Dough createDough() {
        return new ChineseStyleDough();
    }

    @Override
    public Cheese createCheese() {
        return new ChineseStyleCheese();
    }
}

/**
 * 纽约披萨原料工厂，相当于抽象工厂模式中的具体工厂
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory{

    @Override
    public Dough createDough() {
        return new NYStyleDough();
    }

    @Override
    public Cheese createCheese() {
        return new NYStyleCheese();
    }
}

/**
 * Cheese，相当于抽象工厂模式中的抽象产品
 */
public abstract class Cheese {
}

/**
 * Dough，相当于抽象工厂模式中的抽象产品
 */
public abstract class Dough {
}

/**
 * 中国风格的Dough，相当于抽象工厂模式中的具体产品
 */
public class ChineseStyleDough extends Dough{
    public ChineseStyleDough() {
        System.out.print("    中国风格的Dough ");
    }
}

/**
 * 纽约风格的Dough，相当于抽象工厂模式中的具体产品
 */
public class NYStyleDough extends Dough {
    public NYStyleDough() {
        System.out.print("    纽约风格的Dough ");
    }
}

/**
 * 中国风格的Cheese，相当于抽象工厂模式中的具体产品
 */
public class ChineseStyleCheese extends Cheese{
    public ChineseStyleCheese() {
        System.out.println("中国风格的Cheese");
    }
}

/**
 * 纽约风格的Cheese，相当于抽象工厂模式中的具体产品
 */
public class NYStyleCheese extends Cheese{
    public NYStyleCheese() {
        System.out.println("纽约风格的Cheese");
    }
}

/**
 * 披萨，相当于抽象工厂模式中的抽象客户
 */
public abstract class Pizza {
    Dough dough;
    Cheese cheese;
}

/**
 * CheesePizza，相当于抽象工厂模式中的客户
 */
public class CheesePizza extends Pizza{
    private PizzaIngredientFactory pizzaIngredientFactory;

    public CheesePizza(PizzaIngredientFactory pizzaIngredientFactory) {
        this.pizzaIngredientFactory = pizzaIngredientFactory;
        // 通过工厂生产Dough
        pizzaIngredientFactory.createDough();
        // 通过工厂生产Cheese
        pizzaIngredientFactory.createCheese();
    }

    public CheesePizza() {
    }
}

/**
 * 抽象的披萨商店
 */
public abstract class PizzaStore {
    protected abstract Pizza createPizza(String type);
}

/**
 * 中国披萨店
 */
public class ChinesePizzaStore extends PizzaStore{

    @Override
    protected Pizza createPizza(String type) {
        if ("cheese".equals(type)) {
            // 生产中国风味的CheesePizza，传给客户一个中国风味的原料工厂
            return new CheesePizza(new ChinesePizzaIngredientFactory());
        } else {
            return null;
        }
    }
}

/**
 * 纽约披萨店
 */
public class NYPizzaStore extends PizzaStore{
    @Override
    protected Pizza createPizza(String type) {
        if ("cheese".equals(type)) {
            // 生产纽约风味的CheesePizza，传给客户一个纽约风味的原料工厂
            return new CheesePizza(new NYPizzaIngredientFactory());
        } else {
            return null;
        }
    }
}

/**
 * 集团老板，开设多家连锁披萨店
 */
public class Boss {
    public static void main(String[] args) {
        // 中国风味的披萨店
        ChinesePizzaStore chinesePizzaStore = new ChinesePizzaStore();
        // 纽约风味的披萨店
        NYPizzaStore nyPizzaStore = new NYPizzaStore();

        // 中国风味的CheesePizza
        System.out.println("中国风味的CheesePizza：");
        chinesePizzaStore.createPizza("cheese");

        // 纽约风味的CheesePizza
        System.out.println("纽约风味的CheesePizza：");
        nyPizzaStore.createPizza("cheese");
    }
}

中国风味的CheesePizza：
    中国风格的Dough 中国风格的Cheese
纽约风味的CheesePizza：
    纽约风格的Dough 纽约风格的Cheese

Process finished with exit code 0