2.3 抽象工厂模式（Abstract Factory）

抽象工厂模式（Abstract Factory）模式定义？ 应用场景是啥？ 有几种模式？分别示例

抽象工厂模式定义：

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要知道（或关心）实际生产出的具体产品是什么。这样做可以让一个系统独立于它的产品的创建、组合和表示方式。

应用场景：

1. 系统不应依赖于产品类实例如何被创建、组合和表达的细节：这对于所有形式的工厂模式都是重要的，因为它们通过将产品的实现细节与其使用相分离，使系统更加模块化。
2. 系统需要与多个系列产品一起工作：抽象工厂可以保证这些产品系列中的对象是兼容的。
3. 强调一系列相关的产品对象的设计以便进行联合使用：抽象工厂定义了一组产品，这些产品可以一起使用，这样的设计更加用户友好。
4. 提供一个产品库，而只想显示它们的接口而不是实现：抽象工厂的每个具体工厂都产生一系列产品，而这些产品通过抽象接口呈现出来，隐藏了具体的实现。

抽象工厂模式的实现：

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

interface AbstractProductB {
    void eat();
}

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

class ProductA2 implements AbstractProductA {
    public void use() {
        System.out.println("Using Product A2");
    }
}

// 具体产品B1和B2
class ProductB1 implements AbstractProductB {
    public void eat() {
        System.out.println("Eating Product B1");
    }
}

class ProductB2 implements AbstractProductB {
    public void eat() {
        System.out.println("Eating Product B2");
    }
}

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

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA1();
    }
    
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ProductA2();
    }
    
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

// 客户端代码
public class Client {
    private AbstractProductA productA;
    private AbstractProductB productB;
    
    public Client(AbstractFactory factory) {
        productA = factory.createProductA();
        productB = factory.createProductB();
    }
    
    public void useProducts() {
        productA.use();
        productB.eat();
    }
    
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        Client client1 = new Client(factory1);
        client1.useProducts();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        Client client2 = new Client(factory2);
        client2.useProducts();
    }
}

在这个例子中，Client 类不需要知道具体的产品类（ProductA1, ProductA2, ProductB1, ProductB2），它只与抽象产品接口 (AbstractProductA 和 AbstractProductB) 以及抽象工厂接口 (AbstractFactory) 打交道。产品的具体实例化过程被封装在具体的工厂类中（ConcreteFactory1 和 ConcreteFactory2）。

注意事项：

• 抽象工厂模式难以支持新种类产品的变化。这是因为 AbstractFactory 接口确定了可以创建的产品集合，支持新种类的产品就需要扩展该工厂接口，进而影响所有的具体工厂类。
• 抽象工厂模式的使用可以确保客户端和工厂方法以及产品的具体实现之间的解耦，这对系统的维护和扩展都是有益的。