设计模式【2.2】-- 工厂模式怎么演变成抽象工厂模式?

还记得之前的工厂方法模式么？

设计模式【2.1】-- 简单工厂模式怎么演变成工厂方法模式？

现在老板更加富有了，除了水果，还准备搞点其他的生意，再做点服装生意。水果工厂和服装工厂明显就不是同一种东西，肯定不能放到一个工厂里面生产，服装也有好几种，但是不同的工厂，也是老板自己的，老板希望能够把握大局，所以不同工厂，肯定是有同一个特征的，也就是他们都是工厂，并且都是老板的。

先来创建一个接口Fruit.java：

public interface Fruit {
    public void print();
}

创建水果的实体类Apple.java:

public class Apple implements Fruit{
    @Override
    public void print() {
        System.out.println("苹果产品生产出来了");
    }
}

Pear.java:

public class Pear implements Fruit{
    @Override
    public void print() {
        System.out.println("雪梨产品生产出来了");
    }
}

除了水果产品，我们还有服装产品，因此先创建一个Clothes.java:

public interface Clothes {
    public void process();
}

服装厂有哪些产品呢？先生产两种Jeans.java:

public class Jeans implements Clothes{
    @Override
    public void process() {
        System.out.println("牛仔裤生产出来了");
    }
}

Dresses.java:

public class Dresses implements Clothes{
    @Override
    public void process() {
        System.out.println("连衣裙生产出来了");
    }
}

既然也要生产水果产品，也要生产服装产品，那就先搞个抽闲工厂AbstractFactory.java，有两个方法，一个生产水果产品，一个生产服装产品：

public abstract class AbstractFactory {
    // 生产水果
    public abstract Fruit getFruit(String name);
    // 生产衣服
    public abstract Clothes getClothes(String name);
}

上面只是工厂的大致模型，但是每一种工厂都有自己的特点，所以水果工厂FruitFactory.java要自己实现生产水果产品的过程:

public class FruitFactory extends AbstractFactory{

    @Override
    public Fruit getFruit(String name) {
        if(name==null){
            return null;
        }
        if("Apple".equalsIgnoreCase(name)){
            return new Apple();
        }else if("Pear".equalsIgnoreCase(name)){
            return new Pear();
        }
        return null;
    }

    @Override
    public Clothes getClothes(String name) {
        return null;
    }
}

同样，衣服工厂ClothesFactory.java也要自己实现工厂的具体生产过程:

public class ClothesFactory extends AbstractFactory {
    @Override
    public Fruit getFruit(String name) {
        return null;
    }

    @Override
    public Clothes getClothes(String name) {
        if (name == null) {
            return null;
        }
        if ("Jeans".equalsIgnoreCase(name)) {
            return new Jeans();
        } else if ("Dresses".equalsIgnoreCase(name)) {
            return new Dresses();
        }
        return null;
    }
}

不同的工厂怎么管理呢？需要一个工厂创造器FactoryProducer.java，把不同的工厂造出来，也可以理解成为工厂的工厂：

public class FactoryProducer {
    public static AbstractFactory getFactory(String type) {
        if (type == null) {
            return null;
        }
        if ("Fruit".equalsIgnoreCase(type)) {
            return new FruitFactory();
        } else if ("Clothes".equalsIgnoreCase(type)) {
            return new ClothesFactory();
        }
        return null;
    }
}

测试代码FactoryTest.java:

public class FactoryTest {
    public static void main(String[] args) {
        AbstractFactory fruitFactory = FactoryProducer.getFactory("Fruit");
        Fruit apple = fruitFactory.getFruit("apple");
        apple.print();

        Fruit pear = fruitFactory.getFruit("pear");
        pear.print();

        AbstractFactory clothesFactory = FactoryProducer.getFactory("Clothes");
        Clothes jeans = clothesFactory.getClothes("jeans");
        jeans.process();

        Clothes dresses = clothesFactory.getClothes("Dresses");
        dresses.process();
    }
}

测试结果如下：

苹果产品生产出来了
雪梨产品生产出来了
牛仔裤生产出来了
连衣裙生产出来了

抽象工厂模式，本质上也是工厂模式，也是属于创建型模式，用于创建对象。其特点是用一个超级工厂创建其他的工厂，也就是工厂的工厂。每一个工厂管理一类的产品，比如水果工厂主要负责生产水果产品，服装工厂服装生产服装产品。而每一种工厂本质上都是工厂，都从抽象工厂中衍生出来，只是做了不同的实现。

• 优点：如果需要增加其他的工厂，容易拓展，增加工厂中的产品，也可以拓展。不需要关心创建的细节，相同的类型产品放置在一起创建。
• 缺点：增加了抽象的复杂度，理解难度增加。