抽象工厂模式

用来创建一系列相关或相互依赖的对象的接口，而无需指定它们具体的类。

抽象工厂.png

我们举个例子来说明这种关系。请考虑早餐店里早餐的创建过程，中式早餐包括豆浆，油条，西式的包括牛奶，面包，下面我们先来创建早餐类。

interface Drinks {
    void drink();
}

class Soybean implements Drinks {

    @Override
    public void drink() {
        System.out.println("drink Soybean");
    }
}

class Milk implements Drinks {

    @Override
    public void drink() {
        System.out.println("drink milk");
    }
}

interface Pasta {
    void eat();
}

class YouTiao implements Pasta {

    @Override
    public void eat() {
        System.out.println("eat you tiao");
    }
}

class Bread implements Pasta {

    @Override
    public void eat() {
        System.out.println("eat bread");
    }
}

先创建了饮品和面食类，接下来创建抽象工厂类

interface AbstractBreakfastFactory {
    Drinks makeDrinks();
    Pasta makePasta();
}

class TraditionalBreakfastFactory implements AbstractBreakfastFactory {

    @Override
    public Drinks makeDrinks() {
        return new Soybean();
    }

    @Override
    public Pasta makePasta() {
        return new YouTiao();
    }
}

class WesternBreakfastFactory implements AbstractBreakfastFactory {

    @Override
    public Drinks makeDrinks() {
        return new Milk();
    }

    @Override
    public Pasta makePasta() {
        return new Bread();
    }
}

我们创建了中式和西式的早餐工厂类分别创建两种不同类型的早餐，接下来是早餐店使用工厂类创建不同的早餐。

AbstractBreakfastFactory factory = new TraditionalBreakfastFactory();
Drinks drinks = factory.makeDrinks();
Pasta pasta = factory.makePasta();

这样还会创建工程类，我们可以创建一个抽象工厂的工程类，通过类型来创建工程。

class SimpleFactoryProducer {
    public static AbstractBreakfastFactory getFactory(int type) {
        if (type == AbstractBreakfastFactory.TYPE_WESTERN) {
            return new WesternBreakfastFactory();
        } 

        return new TraditionalBreakfastFactory();
    }
}

        AbstractBreakfastFactory factory = SimpleFactoryProducer.getFactory(AbstractBreakfastFactory.TYPE_TRADITIONAL);
        Drinks drinks = factory.makeDrinks();
        Pasta pasta = factory.makePasta();

参考：《设计模式-可复用面向对象软件的基础》