设计模式-抽象工厂模式

定义：为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类。

使用场景：一个对象族有相同的约束时可以使用抽象工厂模式。举个例子，Android、iOS、Window Phone下都有短信软件和拨号软件，两者都属于Software软件的范畴，但是它们所在的操作系统平台不一样，即便是同一家公司出品的软件，其代码实现逻辑也是不同的，这时候就可以考虑使用抽象工厂模式来生产Android、iOS、Window phone下的短信软件和拨号软件。

UML类图

主要分为4类

1、抽象工厂角色，声明了一组用于创建一种产品的方法，每一个方法对应一种产品。

2、具体工厂角色，实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上图的ConcreteFactory1和ConcreteFactory2。

3、抽象产品角色，它为每种产品声明接口，比如上图的AbstractProductA和AbstractProductB。

4、具体产品角色，它定义具体工厂生产具体的产品对象，实现抽象产品接口中声明的业务方法。

简单实现

在工厂模式中的例子，Q3 、Q7后来经过改装优化后，无法在一条生产线上继续进行生产，他们之间的差别现在比较大。

主要区别是 发动机：Q3是国产的 Q7是原装进口的；轮胎：Q3是普通的，Q7是全尺寸越野轮胎；制动系统Q3是普通制动，Q7是性能较好的制动系统。Q3、Q7对应的是一系列车，而发动机、轮胎、制动系统对应的是一系列零部件。

这时候将抽象工厂模式应用到其中，首先，汽车工厂要生产轮胎、发动机、制动系统这3种部件。

抽象工厂类

/**
 * 抽象工厂
 */
public abstract class CarFactory {

    /**
     * 生产轮胎
     *
     * @return
     */
    public abstract ITire createTire();

    /**
     * 生产发动机
     *
     * @return
     */
    public abstract IEngine createEngine();


    /**
     * 生产制动系统
     *
     * @return
     */
    public abstract IBrake createBrake();
}

具体工厂类

public class Q3Factory extends CarFactory {
    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

public class Q7Factory extends CarFactory {
    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBrake() {
        return new SeniorBrake();
    }
}

抽象产品类

/**
 * 抽象轮胎
 */
public interface ITire {

    void tire();
}

/**
 * 抽象发动机
 */
public interface IEngine {

    void engine();
}

/**
 * 抽象制动系统
 */
public interface IBrake {

    void brake();
}

具体产品类

轮胎：

/**
 * 具体 普通轮胎
 */
public class NormalTire implements ITire {
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

/**
 * 具体 越野轮胎
 */
public class SUVTire implements ITire {
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

发动机：

/**
 * 具体 国产发动机
 */
public class DomesticEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}

/**
 * 具体 进口发动机
 */
public class ImportEngine implements IEngine {
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

制动系统：

/**
 * 具体 普通制动系统
 */
public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动系统");
    }
}

/**
 * 具体 高级制动系统
 */
public class SeniorBrake implements IBrake {

    @Override
    public void brake() {
        System.out.println("高级制动系统");
    }
}

客户端调用：

public class Client {
    public static void main(String[] args) {
        //创建一个生产Q3的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();

        //创建一个生产Q7的工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEngine().engine();
        factoryQ7.createBrake().brake();

    }
}

如果此时Q5系列车又进行了改进，那么又得创建Q5车型的对应的工厂，方便了扩展，但同时有个弊端也体现出来，那就是工厂类过多，导致类文件非常多，实际开发中权衡利弊吧。

总结:

一个显著的优点就是分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象该工厂模式在切换产品类时更加灵活，容易。

缺点：类文件爆炸性增加，不太容易扩展新的产品类，因为每当增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。