设计模式之抽象工厂模式

定义

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定它们的具体类。
抽象工厂模式是工厂模式的升级版
举个栗子：
以工厂模式中的例子继续：
定义一个产品接口（也可以是抽象类），

//产品接口
public interface Product {
    void method1();
}

两个产品抽象子类实现这个接口，每个产品子类中有不同的抽象方法

//抽象产品类A
public abstract class AbstractProductA implements Product {
    @Override
    public void method1() {

    }
    public abstract void method2();
}

//抽象产品类B
public abstract class AbstractProductB implements Product {
    @Override
    public void method1() {

    }
    public abstract void method2();
}

每个产品抽象类有不同的子类实现类

//产品类A的实现类A1
public class ProductA1 extends AbstractProductA {
    @Override
    public void method2() {
        System.out.println("ProductA1的实现方法");
    }
}

//产品类A的实现类A2
public class ProductA2 extends AbstractProductA {
    @Override
    public void method2() {
        System.out.println("ProductA2的实现方法");
    }
}

//产品类B的实现类B1
public class ProductB1 extends AbstractProductB {
    @Override
    public void method2() {
        System.out.println("ProductB1的实现方法");
    }
}

//产品类A的实现类B2
public class ProductB2 extends AbstractProductB {
    @Override
    public void method2() {
        System.out.println("ProductB2的实现方法");
    }
}

定义一个抽象工厂，用来创建产品A和产品B

public abstract class AbstractFactory {
    //创建产品A家族
    public abstract AbstractProductA createProductA();

    //创建产品B家族
    public abstract AbstractProductB createProductB();
}

接下来定义两个抽象工厂的实现类，分别用来创建1（A1、B1）和2（A2、B2）产品

public class Factory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

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

public class Factory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

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

接下来通过客户端场景类进行调用：

public class Client {
    public static void main(String[] args) {
        Factory1 factory1 = new Factory1();
        Factory2 factory2 = new Factory2();

        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductA productA2 = factory2.createProductA();

        AbstractProductB productB1 = factory1.createProductB();
        AbstractProductB productB2 = factory2.createProductB();
    }
}

在客户端场景类中，所有的方法与实现类都没有关系，也就是说只需要知道它的工厂方法就可以创建一个对象，不需要关心它的实现类

优缺点

优点
* 封装性，高层模块只需要关心抽象，不需要关心每个产品的实现类，只要知道工厂是谁就可以创建出对象
* 产品族内的约束为非公开状态。生产过程对于高层模块来说是透明的，在具体产品族内的约束它是不需要知道的，这个约束是在工厂内实现的。

缺点
产品族纵向扩展困难，比如增加一个ProductC，程序改动较大，AbstractFactory需要增加一个方法，两个实现类工厂需要修改。而横向扩展是比较容易的，比如增加一个等级3，只需要增加一个工厂类即可

应用场景

当一个对象族（或是一组没有任何关系的对象）都有相同的约束，就可以使用抽象工厂模式。