抽象工厂模式

抽象工厂模式
（《设计模式解析与实战》读书笔记）

一、定义
为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体类。
二、使用场景
一个对象族有相同的约束。
举个例子：奔驰和奥迪都属于汽车（抽象工厂），这两种车有各自的工厂生产线（具体工厂），但每种车的型号又不相同（抽象产品），每种车的每种型号又有各自的生产线（具体产品）。
抽象工厂：声明了一组用于创建一种产品的方法，每一个方法对应一种产品；
具体工厂：实现了在抽象工厂中定义的创建产品的方法，生成一组具体的产品种类。
抽象产品：为每种产品声明接口；
具体产品：定义具体工厂生产的具体产品对象。
三、抽象工厂模式的通用模式代码

/**
 * 抽象产品类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();
    }
}

public class Client {

    public static void main(String[] args) {
        AbstractFactory factoryA1 = new ConcreteFactory1();
        factoryA1.createProductA().method();
        System.out.println("------------");
        AbstractFactory factoryB1 = new ConcreteFactory1();
        factoryB1.createProductB().method();
        System.out.println("------------");
        AbstractFactory factoryA2 = new ConcreteFactory2();
        factoryA2.createProductA().method();
        System.out.println("------------");
        AbstractFactory factoryB2 = new ConcreteFactory2();
        factoryB2.createProductB().method();
        System.out.println("------------");
    }
}

运行结果：

四、优缺点
优点：
分离接口与实现。客户端使用抽象工厂来创建需要的对象，不需要知道具体的实现是谁。所以该模式在切换产品类时更加灵活、容易。
缺点：
(1)类文件的爆炸性增长；
(2)不太容易扩展新的产品类。因为每增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。

所以该模式不推荐使用，大部分情况使用工厂模式即可解决。