什么是工厂模式?
工厂是一种创建型设计模式。通俗来讲就是提供一种封装对象创建的方式,将对象的创建和使用区分开。就是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(); } }