设计模式之抽象工厂模式【Abstract Factory Pattern】

抽象工厂模式主要是用来为一个产品族的选择实现。

1、定义

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

2、使用场景

• 如果一个系统希望独立于它的产品的创建、组合和表示的时候。也就是系统只直到产品的接口，而不关心实现的时候。
• 如果一个系统要由多个产品系列中的一个来配置的时候。也就是可以动态地切换产品族的时候。
• 一个产品族有相同的约束的时候。

3、UML图

4、示例代码

• 定义各种A产品

public abstract class AbstractProductA {
    public abstract void method();
}

public class ConcreteProductA1 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品 A1 的方法");
    }
}

public class ConcreteProductA2 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品 A2 的方法");
    }
}

• 定义各种B产品

public abstract class AbstractProductB {
    public abstract void method();
}

public class ConcreteProductB1 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品 B1 的方法");
    }
}

public class ConcreteProductB2 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品 B2 的方法");
    }
}

• 抽象工厂，定义生产 A、B 产品的接口

public abstract class AbstractFactory {

    public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();
}

• 定义生产 1 系列 A、B 产品的工厂

public class ConcreteFactory1 extends AbstractFactory {

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

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

• 定义生产 2 系列 A、B 产品的工厂

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 factory1 = new ConcreteFactory1();
        AbstractProductA a1 = factory1.createProductA();
        AbstractProductB b1 = factory1.createProductB();
        a1.method();
        b1.method();

        AbstractFactory factory2 = new ConcreteFactory1();
        AbstractProductA a2 = factory2.createProductA();
        AbstractProductB b2 = factory2.createProductB();
        a2.method();
        b2.method();
    }
}

运行结果：

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