7.工厂模式2024-05-29

工厂模式（Factory Pattern）

介绍#

工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但由子类决定实例化哪一个类。这样，工厂方法使一个类的实例化延迟到其子类。
包括简单工厂模式和工厂方法模式。

使用场景#

当一个类不知道它需要创建的对象的确切类型时。
当一个类希望由其子类来指定它创建的对象时。
当类的实例化过程需要被集中管理和控制时。

类图#

+--------------------+        +------------------+
|     Creator        |        |   ConcreteCreator|
+--------------------+        +------------------+
| + FactoryMethod()  |<-------| + FactoryMethod()|
+--------------------+        +------------------+
          ^                            ^
          |                            |
+--------------------+        +------------------+
|     Product        |        |   ConcreteProduct|
+--------------------+        +------------------+
|                    |        |                  |
+--------------------+        +------------------+

示例代码#

产品接口和具体产品类#

// 产品接口
public interface IProduct
{
    void Operation();
}

// 具体产品类 A
public class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation from ConcreteProductA");
    }
}

// 具体产品类 B
public class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation from ConcreteProductB");
    }
}

创建者类和具体创建者类#

// 创建者抽象类
public abstract class Creator
{
    // 工厂方法
    public abstract IProduct FactoryMethod();

    // 其他逻辑
    public void SomeOperation()
    {
        // 调用工厂方法创建产品
        IProduct product = FactoryMethod();
        // 使用产品
        product.Operation();
    }
}

// 具体创建者类 A
public class ConcreteCreatorA : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ConcreteProductA();
    }
}

// 具体创建者类 B
public class ConcreteCreatorB : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ConcreteProductB();
    }
}

客户端代码#

class Program
{
    static void Main(string[] args)
    {
        // 创建具体创建者A
        Creator creatorA = new ConcreteCreatorA();
        creatorA.SomeOperation();

        // 创建具体创建者B
        Creator creatorB = new ConcreteCreatorB();
        creatorB.SomeOperation();
    }
}

输出结果#

Operation from ConcreteProductA
Operation from ConcreteProductB

工厂模式和简单工厂的区别#

简单工厂模式#

简单工厂模式（Simple Factory Pattern）是一种创建型模式，它定义了一个工厂类，该类可以根据传入的参数，决定创建哪一种产品类的实例。简单工厂通常使用一个静态方法来创建对象。

简单工厂示例代码#

public interface IProduct
{
    void Operation();
}

public class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation from ConcreteProductA");
    }
}

public class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine("Operation from ConcreteProductB");
    }
}

public class SimpleFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid type");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        IProduct productA = SimpleFactory.CreateProduct("A");
        productA.Operation();

        IProduct productB = SimpleFactory.CreateProduct("B");
        productB.Operation();
    }
}

区别#

设计意图：
- 简单工厂模式：通过一个静态方法，根据参数创建不同的产品对象。工厂类负责所有具体产品的创建逻辑。
- 工厂方法模式：将创建对象的逻辑推迟到子类，由子类决定创建哪种具体产品。基类提供一个工厂方法，子类实现这个工厂方法。
类图结构：
- 简单工厂模式：有一个工厂类和多个具体产品类。
- 工厂方法模式：有一个抽象创建者类、多个具体创建者类和多个具体产品类。
扩展性：
- 简单工厂模式：添加新产品需要修改工厂类，违反了开闭原则。
- 工厂方法模式：添加新产品只需要添加新的具体创建者类和具体产品类，不需要修改现有代码，符合开闭原则。
职责分配：
- 简单工厂模式：工厂类承担了所有具体产品的创建职责。
- 工厂方法模式：创建职责分散到不同的具体创建者类中。