设计模式之抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种比较常用的设计模式，其定义如下：Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 即：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。
抽象工厂模式的通用类图如下所示：

AbstractFactory.jpg

  抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式生产需要的对象是一种非常好的解决方式。
我们可以看一下抽象工厂模式的通用代码：

//抽象产品A
abstract class AbstractProductA{
    //每个产品的共有方法
    public void shareMethod(){
    }
    //每个产品相同方法，不同实现
    public abstract void doSomething();
}

//抽象产品B
abstract class AbstractProductB{
    //每个产品的共有方法
    public void shareMethod(){
    }
    //每个产品相同方法，不同实现
    public abstract void doSomething();
}

//具体产品A1
class ProductA1 extends AbstractProductA{

    @Override
    public void doSomething() {
        System.out.println("Product A1 do something!");
    }
}

//具体产品A2
class ProductA2 extends AbstractProductA{

    @Override
    public void doSomething() {
        System.out.println("Product A2 do something!");
    }
}

//具体产品B1
class ProductB1 extends AbstractProductB{

    @Override
    public void doSomething() {
        System.out.println("Product B1 do something!");
    }
}

//具体产品B2
class ProductB2 extends AbstractProductB{

    @Override
    public void doSomething() {
        System.out.println("Product B2 do something!");
    }
}

//抽象工厂类
public abstract class AbstractFactory {
    //创建A类产品
    public abstract AbstractProductA createProductA();
    //创建B类产品
    public abstract AbstractProductB createProductB();
}

//具体工厂1
class Factory1 extends AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

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

//具体工厂2
class Factory2 extends AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

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

//具体工厂3
class Factory3 extends AbstractFactory{

    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

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

//客户端
class Clients{
    public static void main(String[] args) {
        //创建三个工厂
        AbstractFactory factory1 = new Factory1();
        AbstractFactory factory2 = new Factory2();
        AbstractFactory factory3 = new Factory3();
        
        //工厂1生产商品
        AbstractProductA f1pA = factory1.createProductA();
        AbstractProductB f1pB = factory1.createProductB();
        f1pA.doSomething();
        f1pB.doSomething();
        
        //工厂2生产商品
        AbstractProductA f2pA = factory2.createProductA();
        AbstractProductB f2pB = factory2.createProductB();
        f2pA.doSomething();
        f2pB.doSomething();
        
        //工厂3生产商品
        AbstractProductA f3pA = factory3.createProductA();
        AbstractProductB f3pB = factory3.createProductB();
        f3pA.doSomething();
        f3pB.doSomething();
        
    }
}

通用源码的类图如下所示：

ABF.jpg

抽象工厂模式的应用

抽象工厂模式的优点

• 封装性，高层模块不需要关心产品的实现类，只需要关心接口即可。
• 产品组内的约束为非公开状态。

抽象工厂模式的缺点

抽象工厂模式的最大缺点就是产品组扩展非常困难，增加产品会导致工厂内部代码的改动，侵入性比较大。

抽象工厂模式的应用场景

抽象工厂模式的应用场景定义非常简单：一个对象组（或者一组没有任何关系的对象）都有相同的约束，则可以试用抽象工厂模式，且后期产品组基本无改动，则可以应用抽象工厂模式。

《注》以上内容总结自秦小波-《设计模式之禅》，仅为个人学习笔记。