Unity 中常见的开发设计模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了Unity 中常见的开发设计模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

以下是 Unity 中常见的开发设计模式的详细介绍：

单例模式

介绍

单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供全局访问点来访问该实例。

方法

单例模式的实现方法是将类的构造函数私有化，这样就不能通过 new 关键字来创建该类的实例。然后，在类中定义一个静态方法来获取该类的唯一实例，如果该实例不存在，则创建一个新的实例并返回。

举例子

以下是一个使用单例模式实现的 GameManager 类的示例：

public class GameManager
{
    private static GameManager instance;

    private GameManager() { }

    public static GameManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new GameManager();
            }
            return instance;
        }
    }

    public void StartGame()
    {
        // ...
    }

    public void EndGame()
    {
        // ...
    }
}

在上面的示例中，GameManager 类的构造函数被私有化，而 Instance 属性则提供了全局访问点来访问 GameManager 的唯一实例。其他类可以通过 GameManager.Instance 来访问 GameManager 的实例，并调用其公共方法。

工厂模式

介绍

工厂模式是一种常见的设计模式，它将对象的创建委托给一个工厂类，从而使客户端代码与具体类的实例化分离。

方法

工厂模式的实现方法是定义一个抽象工厂类或接口，并在其中声明一个用于创建对象的工厂方法。然后，创建具体工厂类来实现工厂方法，该方法将实例化具体类的对象并返回。客户端代码只需要调用工厂方法即可获取所需的对象，而不需要直接实例化具体类。

举例子

以下是一个使用工厂模式实现的 EnemyFactory 类的示例：

public abstract class Enemy
{
    public abstract void Attack();
}

public class Slime : Enemy
{
    public override void Attack()
    {
        // ...
    }
}

public class Goblin : Enemy
{
    public override void Attack()
    {
        // ...
    }
}

public abstract class EnemyFactory
{
    public abstract Enemy CreateEnemy();
}

public class SlimeFactory : EnemyFactory
{
    public override Enemy CreateEnemy()
    {
        return new Slime();
    }
}

public class GoblinFactory : EnemyFactory
{
    public override Enemy CreateEnemy()
    {
        return new Goblin();
    }
}

在上面的示例中，Enemy 是一个抽象基类，Slime 和 Goblin 是具体子类。EnemyFactory 是一个抽象工厂类，SlimeFactory 和 GoblinFactory 是具体工厂类，它们分别实现了 CreateEnemy 方法并返回 Slime 和 Goblin 的实例。客户端代码可以使用 EnemyFactory 来创建所需的 Enemy 对象，而不需要直接实例化 Slime 或 Goblin。

观察者模式

介绍

观察者模式是一种常见的设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并更新。

方法

观察者模式的实现方法是定义一个主题对象，该对象维护一个观察者列表，并提供注册和通知观察者的方法。观察者对象实现一个更新方法，在主题对象发生变化时被调用。客户端代码可以通过注册观察者来监听主题对象的变化，并在更新方法中执行相应的操作。

举例子

以下是一个使用观察者模式实现的 Subject 和 Observer 类的示例：

using System;
using System.Collections.Generic;

public class Subject
{
    private List<Observer> observers = new List<Observer>();

    public void Attach(Observer observer)
    {
        observers.Add(observer);
    }

    public void Detach(Observer observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (Observer observer in observers)
        {
            observer.Update();
        }
    }
}

public abstract class Observer
{
    protected Subject subject;

    public Observer(Subject subject)
    {
        this.subject = subject;
    }

    public abstract void Update();
}

public class ConcreteObserver : Observer
{
    public ConcreteObserver(Subject subject) : base(subject) { }

    public override void Update()
    {
        // ...
    }
}

在上面的示例中，Subject 是一个主题类，它维护了一个 Observer 列表，并提供了 Attach、Detach 和 Notify 方法，用于注册、取消注册和通知观察者。Observer 是一个抽象观察者类，ConcreteObserver 是一个具体观察者类，它们实现了更新方法。客户端代码可以通过创建 ConcreteObserver 的实例并将其注册到 Subject 中来监听主题对象的变化。

委托模式

介绍

委托模式是一种常见的设计模式，它使用委托对象来代表函数，并将其作为参数传递给其他函数。这样可以将代码组织成更小的模块，使其更易于维护和重用。

方法

委托模式的实现方法是定义一个委托类型，并将其作为参数传递给其他函数。其他函数可以将其实现传递给委托对象，从而调用委托对象代表的函数。

举例子

以下是一个使用委托模式实现的 EventHandler 类的示例：

public delegate void EventHandler();

public class EventPublisher
{
    public event EventHandler OnEvent;

    public void RaiseEvent()
    {
        if (OnEvent != null)
        {
            OnEvent();
        }
    }
}

public class EventSubscriber
{
    public void HandleEvent()
    {
        // ...
    }
}

在上面的示例中，EventHandler 是一个委托类型，EventPublisher 是一个事件发布者类，它定义了一个 OnEvent 事件，并在 RaiseEvent 方法中触发该事件。EventSubscriber 是一个事件订阅者类，它定义了一个 HandleEvent 方法，该方法可以作为 EventHandler 委托的实现。客户端代码可以创建 EventPublisher 和 EventSubscriber 的实例，并将 EventSubscriber 的 HandleEvent 方法传递给 EventPublisher 的 OnEvent 事件，从而实现委托模式。

状态模式

介绍

状态模式是一种常见的设计模式，它将对象的行为和状态分离，使得状态的变化不直接影响对象的行为。

方法

状态模式的实现方法是定义一个抽象状态类和多个具体状态类，每个具体状态类代表一个特定的状态，并实现了抽象状态类中定义的一组方法。然后，定义一个包含抽象状态类的成员变量的上下文类，该成员变量表示当前状态，并在上下文类中实现一组方法，用于切换状态和调用当前状态的方法。

举例子

以下是一个使用状态模式实现的 PlayerState 和 Player 类的示例：文章来源地址https://www.toymoban.com/news/detail-447804.html

public abstract class PlayerState
{
    protected Player player;

    public PlayerState(Player player)
    {
        this.player = player;
    }

    public abstract void Move();

    public abstract void Jump();

    public abstract void Attack();
}

public class IdleState : PlayerState
{
    public IdleState(Player player) : base(player) { }

    public override void Move()
    {
        player.State = new RunState(player);
    }

    public override void Jump()
    {
        player.State = new JumpState(player);
    }

    public override void Attack()
    {
        // ...
    }
}

public class RunState : PlayerState
{
    public RunState(Player player) : base(player) { }

    public override void Move()
    {
        // ...
    }

    public override void Jump()
    {
        player.State = new JumpState(player);
    }

    public override void Attack()
    {
        // ...
    }
}

public class JumpState : PlayerState
{