一、引言

        在游戏开发中，设计模式是提高代码可读性、可维护性和可扩展性的重要工具。其中，工厂模式是一种常用的创建型设计模式，它通过提供一个接口来创建对象，而不直接指定其具体类。一般情况下，工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。在GoF设计模式一书中，它将简单工厂模式看做是工厂方法模式的一种特例，所以工厂模式只被分成了工厂方法和抽象工厂两类。

二、工厂模式的三种形式

1. 简单工厂模式（Simple Factory Pattern）：

   • 定义： 简单工厂模式是最简单的工厂模式，通过一个工厂类负责创建所有对象，客户端通过传递不同的参数给工厂类来获取不同的对象实例。
   • 优点： 实现简单，对客户端屏蔽了对象的创建过程。
   • 缺点： 工厂类职责过重，违反了单一职责原则；添加新类型时需要修改工厂类。

使用简单工厂模式实现不同敌人的创建：

// 敌人接口
public interface IEnemy
{
    void Attack();
    void Move();
}

// 具体敌人类A - 僵尸
public class Zombie : IEnemy
{
    public void Attack()
    {
        Debug.Log("Zombie is attacking!");
    }

    public void Move()
    {
        Debug.Log("Zombie is moving!");
    }
}

// 具体敌人类B - 机器人
public class Robot : IEnemy
{
    public void Attack()
    {
        Debug.Log("Robot is shooting!");
    }

    public void Move()
    {
        Debug.Log("Robot is walking!");
    }
}

 接下来，创建简单工厂类，用于根据不同的类型参数创建相应的敌人对象：

// 简单工厂类
public class EnemyFactory
{
    public static IEnemy CreateEnemy(string enemyType)
    {
        switch (enemyType)
        {
            case "Zombie":
                return new Zombie();
            case "Robot":
                return new Robot();
            default:
                Debug.LogError("Unknown enemy type!");
                return null;
        }
    }
}

在游戏中，可以通过调用简单工厂类的CreateEnemy方法来创建不同类型的敌人：

public class GameController : MonoBehaviour
{
    void Start()
    {
        // 使用简单工厂创建不同类型的敌人
        IEnemy zombie = EnemyFactory.CreateEnemy("Zombie");
        IEnemy robot = EnemyFactory.CreateEnemy("Robot");

        // 调用敌人的方法
        zombie.Move();
        zombie.Attack();

        robot.Move();
        robot.Attack();
    }
}

 

1. 工厂方法模式（Factory Method Pattern）：

   • 定义： 工厂方法模式引入了工厂接口，由具体的工厂子类负责创建具体的产品对象。每个产品对象都有对应的工厂子类。
   • 优点： 具体的产品创建延迟到子类，符合开闭原则；每个产品有对应的工厂，扩展时不影响现有代码。
   • 缺点： 每个产品需要一个对应的工厂类，类的数量可能会增加。

使用工厂方法模式实现不同敌人的创建：

首先，定义敌人接口和具体敌人类：

// 敌人接口
public interface IEnemy
{
    void Attack();
    void Move();
}

// 具体敌人类A - 僵尸
public class Zombie : IEnemy
{
    public void Attack()
    {
        Debug.Log("Zombie is attacking!");
    }

    public void Move()
    {
        Debug.Log("Zombie is moving!");
    }
}

// 具体敌人类B - 机器人
public class Robot : IEnemy
{
    public void Attack()
    {
        Debug.Log("Robot is shooting!");
    }

    public void Move()
    {
        Debug.Log("Robot is walking!");
    }
}

然后，定义敌人工厂接口和具体敌人工厂类：

// 敌人工厂接口
public interface IEnemyFactory
{
    IEnemy CreateEnemy();
}

// 具体敌人工厂类A - 僵尸工厂
public class ZombieFactory : IEnemyFactory
{
    public IEnemy CreateEnemy()
    {
        return new Zombie();
    }
}

// 具体敌人工厂类B - 机器人工厂
public class RobotFactory : IEnemyFactory
{
    public IEnemy CreateEnemy()
    {
        return new Robot();
    }
}

 在游戏中，可以通过实例化不同的敌人工厂类来创建不同类型的敌人：

public class GameController : MonoBehaviour
{
    void Start()
    {
        // 使用工厂方法创建不同类型的敌人
        IEnemyFactory zombieFactory = new ZombieFactory();
        IEnemyFactory robotFactory = new RobotFactory();

        IEnemy zombie = zombieFactory.CreateEnemy();
        IEnemy robot = robotFactory.CreateEnemy();

        // 调用敌人的方法
        zombie.Move();
        zombie.Attack();

        robot.Move();
        robot.Attack();
    }
}

1. 抽象工厂模式（Abstract Factory Pattern）：

   • 定义： 抽象工厂模式提供一个接口，用于创建一系列相关或依赖的对象，而不需要指定它们的具体类。
   • 优点： 可以创建一组相关的产品对象，符合单一职责原则；易于交换产品系列。
   • 缺点： 扩展新的产品族较为复杂，需要修改抽象工厂接口。

 使用抽象工厂模式实现不同敌人的创建：

首先，定义敌人接口和具体敌人类：

// 敌人接口
public interface IEnemy
{
    void Attack();
    void Move();
}

// 具体敌人类A - 僵尸
public class Zombie : IEnemy
{
    public void Attack()
    {
        Debug.Log("Zombie is attacking!");
    }

    public void Move()
    {
        Debug.Log("Zombie is moving!");
    }
}

// 具体敌人类B - 机器人
public class Robot : IEnemy
{
    public void Attack()
    {
        Debug.Log("Robot is shooting!");
    }

    public void Move()
    {
        Debug.Log("Robot is walking!");
    }
}

然后，定义抽象工厂接口和具体敌人工厂类：

// 抽象工厂接口
public interface IEnemyFactory
{
    IEnemy CreateEnemy();
}

// 具体敌人工厂类A - 僵尸工厂
public class ZombieFactory : IEnemyFactory
{
    public IEnemy CreateEnemy()
    {
        return new Zombie();
    }
}

// 具体敌人工厂类B - 机器人工厂
public class RobotFactory : IEnemyFactory
{
    public IEnemy CreateEnemy()
    {
        return new Robot();
    }
}

接着，定义抽象工厂接口和具体的敌人管理器类，它包含了两个抽象工厂，用于创建不同类型的敌人：

// 抽象敌人管理器接口
public interface IEnemyManager
{
    IEnemyFactory CreateZombieFactory();
    IEnemyFactory CreateRobotFactory();
}

// 具体敌人管理器类
public class EnemyManager : IEnemyManager
{
    public IEnemyFactory CreateZombieFactory()
    {
        return new ZombieFactory();
    }

    public IEnemyFactory CreateRobotFactory()
    {
        return new RobotFactory();
    }
}

在游戏中，可以通过实例化不同的敌人管理器类来创建不同类型的敌人：

public class GameController : MonoBehaviour
{
    void Start()
    {
        // 使用抽象工厂创建不同类型的敌人
        IEnemyManager enemyManager = new EnemyManager();

        IEnemyFactory zombieFactory = enemyManager.CreateZombieFactory();
        IEnemyFactory robotFactory = enemyManager.CreateRobotFactory();

        IEnemy zombie = zombieFactory.CreateEnemy();
        IEnemy robot = robotFactory.CreateEnemy();

        // 调用敌人的方法
        zombie.Move();
        zombie.Attack();

        robot.Move();
        robot.Attack();
    }
}

三、工厂模式的小结

       工厂模式是一种创建型设计模式，旨在提供一种创建对象的接口，但将实际的实例化过程推迟到子类中。这种模式有助于解决对象创建的灵活性和可维护性问题。以下是工厂模式的一些关键点和小结：

1. 定义： 工厂模式定义了一个创建对象的接口，但由子类决定实例化哪个类。它使一个类的实例化延迟到其子类。

2. 主要角色：

   • 抽象产品（Product）： 定义了产品的接口，具体产品实现这个接口。
   • 具体产品（Concrete Product）： 实现了抽象产品接口的具体类。
   • 抽象工厂（Factory）： 声明创建抽象产品对象的接口。
   • 具体工厂（Concrete Factory）： 实现了抽象工厂接口，负责实例化具体产品。

3. 优点：

   • 解耦合： 工厂模式通过将客户端代码与具体类的实例化过程解耦，使得系统更灵活。
   • 扩展性： 新的产品类可以很容易地添加到系统中，无需修改已有代码。

4. 缺点：

   • 每增加一个产品，就需要增加一个具体产品类和对应的具体工厂类，导致类的数量增加。

5. 适用场景：

   • 当一个类不知道它所必须创建的对象的类时。
   • 当一个类希望由它的子类来指定它所创建的对象时。
   • 当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化时。

在工厂模式中，有三个主要的变体：简单工厂模式、工厂方法模式和抽象工厂模式。这些变体在使用场景和实现上有所不同，开发者可以根据具体需求选择适当的工厂模式来实现对象的创建。