Unity工厂模式

什么是工厂模式？
        工厂是一种创建型设计模式。通俗来讲就是提供一种封装对象创建的方式，将对象的创建和使用区分开。就是Unity里面通常用到的创建和管理对象。

工厂模式有什么优点？
        1、封装对象的创建方式，使其更加灵活、易于管理、可扩展、可维护，降低代码的耦合性。

        2、提供一种统一的对象创建方式，代码解读更加容易懂、逻辑更加清晰。

        3、可以根据不同的需求创建不同的对象。

简单工厂模式

定义：简单工厂模式，也称为静态工厂方法，是通过一个静态方法，根据传入的参数决定创建哪一个具体类的实例。

优点：

• 易于理解和实现。
• 集中管理对象的创建过程。

缺点：

• 工厂类容易变得臃肿，不易维护。
• 增加新的产品需要修改工厂类，不符合开闭原则（对扩展开放，对修改关闭）。

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

// 具体产品A
public class ConcreteProductA : IProduct
{
    public void Use()
    {
        Debug.Log("Using Product A");
    }
}

// 具体产品B
public class ConcreteProductB : IProduct
{
    public void Use()
    {
        Debug.Log("Using Product B");
    }
}

// 简单工厂类
public static 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 product type");
        }
    }
}

工厂方法模式

定义：工厂方法模式定义一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法模式让类的实例化推迟到子类。

优点：

• 遵循开闭原则，增加新产品时不需要修改已有的工厂类。
• 更符合面向对象设计原则，易于扩展和维护。

缺点：

         

缺点：增加了系统的抽象性和复杂性。

• 增加了代码的复杂度，需要创建额外的工厂类。

  // 产品接口
  public interface IProduct
  {
      void Use();
  }
  
  // 具体产品A
  public class ConcreteProductA : IProduct
  {
      public void Use()
      {
          Debug.Log("Using Product A");
      }
  }
  
  // 具体产品B
  public class ConcreteProductB : IProduct
  {
      public void Use()
      {
          Debug.Log("Using Product B");
      }
  }
  
  // 抽象工厂接口
  public interface IFactory
  {
      IProduct CreateProduct();
  }
  
  // 具体工厂A
  public class ConcreteFactoryA : IFactory
  {
      public IProduct CreateProduct()
      {
          return new ConcreteProductA();
      }
  }
  
  // 具体工厂B
  public class ConcreteFactoryB : IFactory
  {
      public IProduct CreateProduct()
      {
          return new ConcreteProductB();
      }
  }
  
  // 客户端代码
  public class Client : MonoBehaviour
  {
      void Start()
      {
          IFactory factoryA = new ConcreteFactoryA();
          IFactory factoryB = new ConcreteFactoryB();
  
          IProduct productA = factoryA.CreateProduct();
          IProduct productB = factoryB.CreateProduct();
  
          productA.Use();
          productB.Use();
      }
  }

  抽象工厂模式

  定义：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

• 优点：

• 提供了一种方式将一组相关或依赖的对象一起创建。
• 符合开闭原则和单一职责原则。

  // 产品A接口
  public interface IProductA
  {
      void Use();
  }
  
  // 产品B接口
  public interface IProductB
  {
      void Display();
  }
  
  // 具体产品A1
  public class ConcreteProductA1 : IProductA
  {
      public void Use()
      {
          Debug.Log("Using Product A1");
      }
  }
  
  // 具体产品A2
  public class ConcreteProductA2 : IProductA
  {
      public void Use()
      {
          Debug.Log("Using Product A2");
      }
  }
  
  // 具体产品B1
  public class ConcreteProductB1 : IProductB
  {
      public void Display()
      {
          Debug.Log("Displaying Product B1");
      }
  }
  
  // 具体产品B2
  public class ConcreteProductB2 : IProductB
  {
      public void Display()
      {
          Debug.Log("Displaying Product B2");
      }
  }
  
  // 抽象工厂接口
  public interface IAbstractFactory
  {
      IProductA CreateProductA();
      IProductB CreateProductB();
  }
  
  // 具体工厂1
  public class ConcreteFactory1 : IAbstractFactory
  {
      public IProductA CreateProductA()
      {
          return new ConcreteProductA1();
      }
  
      public IProductB CreateProductB()
      {
          return new ConcreteProductB1();
      }
  }
  
  // 具体工厂2
  public class ConcreteFactory2 : IAbstractFactory
  {
      public IProductA CreateProductA()
      {
          return new ConcreteProductA2();
      }
  
      public IProductB CreateProductB()
      {
          return new ConcreteProductB2();
      }
  }
  
  // 客户端代码
  public class Client : MonoBehaviour
  {
      void Start()
      {
          IAbstractFactory factory1 = new ConcreteFactory1();
          IAbstractFactory factory2 = new ConcreteFactory2();
  
          IProductA productA1 = factory1.CreateProductA();
          IProductB productB1 = factory1.CreateProductB();
          IProductA productA2 = factory2.CreateProductA();
          IProductB productB2 = factory2.CreateProductB();
  
          productA1.Use();
          productB1.Display();
          productA2.Use();
          productB2.Display();
      }
  }