抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是创建型设计模式之一。

定义

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

抽象工厂实例

// 抽象产品类 A
public abstract class AbstractProductA {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

// 抽象产品类 B
public abstract class AbstractProductB {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

//具体产品类 A1
public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品 A1 的方法");
    }
}

//具体产品类 A2
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品 A2 的方法");
    }
}

//具体产品类 B1
public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品 B1 的方法");
    }
}

//具体产品类 B2
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品 B2 的方法");
    }
}

//抽象工厂类
public abstract class AbstractFactory {
    /**
     * 创建产品 A 的方法
     *
     * @return 产品 A 的对象
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建产品 B 的方法
     *
     * @return 产品 B 的对象
     */
    public abstract AbstractProductB createProductB();
}

//具体工厂类 1
public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

//具体工厂类 2
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

虽然抽象工厂方法模式的类繁多，但是，主要还是分为 4 类。

• AbstractFactory：抽象工厂角色，它声明了一组用于创建一种产品的方法，每一个方法对应一种产品，如上述 AbstractFactory 中就定义了两个方法，分别创建产品 A 和产品 B。
• ConcreteFactory：具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上述 ConcreteFactory1 和 ConcreteFactory2。
• AbstractProduct：抽象产品角色，它为每种产品声明接口，如上述 AbstractProductA 和 AbstractProductB。
• ConcreteProduct：具体产品角色，它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法，如上述 ConcreteProductA1、ConcreteProductA2 、ConcreteProductB1 和 ConcreteProductB2。

抽象工厂方法模式的简单实现

汽车工厂需要生产轮胎、发动机、制动系统这 3 种部件，Q3、Q5、Q7 都是一个车系，但是三者之间的零部件差别很大，拿 Q3 和 Q7 来说，Q3使用的发动机是国产的，而 Q7 则是原装进口的；Q3 轮胎是普通轮胎，而 Q7 则是全尺寸越野轮胎；Q3 使用的是普通的制动系统，而 Q7 则是制动性能极好的制动系统，Q3、Q7 对应的是一系列车，而发动机、轮胎、制动系统则对应的是一系列零部件，两者是两种不同的产品类型，这时候就可以将抽象工厂模式应用到其中。

//抽象工厂类
public abstract class CarFactory {
    /**
     * 生产轮胎
     *
     * @return 轮胎
     */
    public abstract ITire createTire();

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

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

轮胎相关类

public interface ITire {
    /**
     * 轮胎
     */
    void tire();
}

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 interface IEngine {
    /**
     * 发动机
     */
    void engine();
}

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 interface IBrake {
    /**
     * 制动系统
     */
    void brake();
}

public class NormalBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

public class SeniorBrake implements IBrake {
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

对于生产 Q3 的工厂，其使用的零部件不同，而生产 Q7 的工厂呢，其零部件也不同。

//Q3 工厂类
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();
    }
}

//Q7 工厂类
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();
    }
}

最后，我们在一个 Client 客户类中模拟。

// 客户类
public class Client {
    public static void main(String[] args) {
        //构造生产 Q3 的工厂
        CarFactory factoryQ3 = new Q3Factory();
        factoryQ3.createTire().tire();
        factoryQ3.createEngine().engine();
        factoryQ3.createBrake().brake();

        System.out.println("-------------------------");

        //构造生产 Q7 的工厂
        CarFactory factoryQ7 = new Q7Factory();
        factoryQ7.createTire().tire();
        factoryQ7.createEngine().engine();
        factoryQ7.createBrake().brake();
    }
}

输出结果如下：

上面只是模拟了两个车系 Q3 和 Q7 的工厂，如果要增加 Q5 的工厂？那么对应的轮胎、制动系统和发动机类又要增加，这里就可以看出抽象工厂方法模式的一个弊端，就是类的徒增，如果工厂类过多，势必导致类文件非常多。

小结

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

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