(4).抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。抽象工厂模式的主要目的是将对象的创建过程与使用过程分离，使得客户端可以不关心对象的具体实现细节。

抽象工厂模式的基本结构

1. AbstractFactory: 定义一个用于创建一系列相关或依赖对象的接口。
2. ConcreteFactory: 实现AbstractFactory接口，负责创建具体的产品族。
3. AbstractProduct: 定义产品族中所有产品的公共接口。
4. ConcreteProduct: 具体的产品类，实现了AbstractProduct接口。
5. Client: 使用AbstractFactory和AbstractProduct接口来操作对象，而不关心具体实现。

示例代码

假设我们要创建两个产品族：FamilyA 和 FamilyB，每个产品族都有两种产品：ProductX 和 ProductY。

1. AbstractFactory 接口

public interface IAbstractFactory
{
    IProductX CreateProductX();
    IProductY CreateProductY();
}

2. ConcreteFactory 实现

// 创建 FamilyA 的工厂
public class ConcreteFactoryA : IAbstractFactory
{
    public IProductX CreateProductX()
    {
        return new ProductXA();
    }

    public IProductY CreateProductY()
    {
        return new ProductYA();
    }
}

// 创建 FamilyB 的工厂
public class ConcreteFactoryB : IAbstractFactory
{
    public IProductX CreateProductX()
    {
        return new ProductXB();
    }

    public IProductY CreateProductY()
    {
        return new ProductYB();
    }
}

3. AbstractProduct 接口

public interface IProductX
{
    void OperationX();
}

public interface IProductY
{
    void OperationY();
}

4. ConcreteProduct 实现

// FamilyA 的 ProductX 实现
public class ProductXA : IProductX
{
    public void OperationX()
    {
        Console.WriteLine("ProductXA operation.");
    }
}

// FamilyA 的 ProductY 实现
public class ProductYA : IProductY
{
    public void OperationY()
    {
        Console.WriteLine("ProductYA operation.");
    }
}

// FamilyB 的 ProductX 实现
public class ProductXB : IProductX
{
    public void OperationX()
    {
        Console.WriteLine("ProductXB operation.");
    }
}

// FamilyB 的 ProductY 实现
public class ProductYB : IProductY
{
    public void OperationY()
    {
        Console.WriteLine("ProductYB operation.");
    }
}

5. Client 类

public class Client
{
    private IProductX _productX;
    private IProductY _productY;

    public Client(IAbstractFactory factory)
    {
        _productX = factory.CreateProductX();
        _productY = factory.CreateProductY();
    }

    public void RunOperations()
    {
        _productX.OperationX();
        _productY.OperationY();
    }
}

示例代码完整版

下面是一个完整的示例，展示了如何使用抽象工厂模式。

using System;

// AbstractFactory 接口
public interface IAbstractFactory
{
    IProductX CreateProductX();
    IProductY CreateProductY();
}

// ConcreteFactoryA 实现
public class ConcreteFactoryA : IAbstractFactory
{
    public IProductX CreateProductX()
    {
        return new ProductXA();
    }

    public IProductY CreateProductY()
    {
        return new ProductYA();
    }
}

// ConcreteFactoryB 实现
public class ConcreteFactoryB : IAbstractFactory
{
    public IProductX CreateProductX()
    {
        return new ProductXB();
    }

    public IProductY CreateProductY()
    {
        return new ProductYB();
    }
}

// AbstractProductX 接口
public interface IProductX
{
    void OperationX();
}

// AbstractProductY 接口
public interface IProductY
{
    void OperationY();
}

// FamilyA 的 ProductX 实现
public class ProductXA : IProductX
{
    public void OperationX()
    {
        Console.WriteLine("ProductXA operation.");
    }
}

// FamilyA 的 ProductY 实现
public class ProductYA : IProductY
{
    public void OperationY()
    {
        Console.WriteLine("ProductYA operation.");
    }
}

// FamilyB 的 ProductX 实现
public class ProductXB : IProductX
{
    public void OperationX()
    {
        Console.WriteLine("ProductXB operation.");
    }
}

// FamilyB 的 ProductY 实现
public class ProductYB : IProductY
{
    public void OperationY()
    {
        Console.WriteLine("ProductYB operation.");
    }
}

// Client 类
public class Client
{
    private IProductX _productX;
    private IProductY _productY;

    public Client(IAbstractFactory factory)
    {
        _productX = factory.CreateProductX();
        _productY = factory.CreateProductY();
    }

    public void RunOperations()
    {
        _productX.OperationX();
        _productY.OperationY();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 使用 FamilyA 的工厂
        Console.WriteLine("Using FamilyA:");
        IAbstractFactory familyAFactory = new ConcreteFactoryA();
        Client clientA = new Client(familyAFactory);
        clientA.RunOperations();

        Console.WriteLine();

        // 使用 FamilyB 的工厂
        Console.WriteLine("Using FamilyB:");
        IAbstractFactory familyBFactory = new ConcreteFactoryB();
        Client clientB = new Client(familyBFactory);
        clientB.RunOperations();
    }
}

输出结果

Using FamilyA:
ProductXA operation.
ProductYA operation.

Using FamilyB:
ProductXB operation.
ProductYB operation.

抽象工厂模式的优点

1. 松耦合：客户端只需要知道抽象工厂和抽象产品的接口，不需要知道具体的产品类。
2. 易于扩展：如果需要添加新的产品族，只需新增一个具体的工厂类即可，而不需要修改现有的代码。
3. 一致性：确保同一产品族中的产品是兼容的。

抽象工厂模式的缺点

1. 增加复杂性：引入了更多的接口和类，增加了系统的复杂性。
2. 难以支持新种类的产品：如果需要添加一个新的产品类型，必须修改所有的工厂类和产品接口。

总结

抽象工厂模式适用于以下场景：

• 系统需要独立于产品创建、组合和表示时。
• 系统要由多个产品系列中的一个来配置时。
• 当需要强调一系列相关的产品对象的设计以便进行联合使用时。