抽象工厂模式

什么是抽象工厂模式？

抽象工厂（Abstract Factory）提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。通常用于需要创建多个产品系列的情况。

何时使用

• 需要创建一系列相关对象，且这些对象属于同一产品族的场景。
• 当产品的创建过程需要保证一致性时。
• 系统需要独立于产品的创建和组合过程。

示例

// 抽象产品A
interface AbstractProductA {
    void use();
}

// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}

// 抽象产品B
interface AbstractProductB {
    void use();
}

// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void use() {
        System.out.println("Using Product B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void use() {
        System.out.println("Using Product B2");
    }
}

// 抽象工厂
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

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

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

/**
 * 客户端
 */
public class AbstractFactoryPatternExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.use();

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.use();
    }
}