游戏设计模式
单列模式
概念
单例模式是一种创建型设计模式，可以保证一个类只有一个实例，并提供一个访问该实例的全局节点。
优点
- 可以派生：在单例类的实例构造函数中可以设置以允许子类派生。
- 受控访问：因为单例类封装他的唯一实例，所以它可以严格的控制其他程序怎样以及何时访问它。
- 可以获得一个指向该实例的全局访问节点。
- 仅在首次请求单例对象时对其进行初始化。
缺点
- 违反了单一职责原则。
- 单例模式一般不要支持序列化，因为这也有可能导致多个对象实例。
- 多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
组成
1.单例(Singleton)类声明了一个名为getInstance的静态方法来返回其所属类的一个相同实例。
2.单例的构造函数必须私有化，即对客户端(Client)隐藏。调用getInstance方法必须是获取单例对象的唯一方式。
案例
方式1
public class Singleton
{
private Singleton() { }
private static Singleton instance;
public static Singleton GetInstance
{
get
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}方式2：多线程单例
class SingletonThread
{
private SingletonThread() { } //私有化构造
private static volatile SingletonThread instance;
private static object lockHelper = new Object { };
public static SingletonThread GetInstance
{
get
{
// 双重校验，为避免额外的性能消耗。
if (instance == null)
{
// 当第一个线程运行到这里时，此时会对lock加锁。
// 当第二个线程运行该方法时，首先检测到lock加锁状态，该线程就会挂起等待第一个线程解锁。
lock (lockHelper)
{
if (instance == null)
{
instance = new SingletonThread();
}
}
}
return instance;
}
}
}方式3
class SingletonRead
{
private SingletonRead() { }
//只要访问就会被执行静态构造器，不使用不会进行实例化
public static readonly SingletonRead Instance = new SingletonRead();
//等价于
//public static readonly SingletonRead Instance;
//static SingletonRead ()
//{
// Instance = new SingletonRead ();
//}
}MVC模式
概念
MVC设计模式一般指MVC框架，M(Model)指数据模型层，V(View)指视图层，C(Controller)指控制层。其设计目的是将M和V的实现代码分离，使同一个程序可以有不同的表现形式。
优点
- 多视图共享一个模型，大大提高了代码的重用性。
- MVC三个模块相互独立，松耦合架构。
- 控制器提高了应用程序的灵活性和可配置性。
- 有利于软件工程化管理。
总之，我们通过MVC设计模式最终可以打造出一个松耦合+高可重用性+高可适用性的完美架构。
缺点
- 原理复杂。
- 增加了系统结构和实现的复杂性。
- 视图对模型数据的低效率访问。
MVC并不适合小型甚至中型规模的项目，花费大量时间将MVC应用到规模并不是很大的应用程序，通常得不偿失，所以对于MVC设计模式的使用要根据具体的应用场景来决定。
组成
- 视图层(View)：负责格式化数据并把它们呈现给用户，包括数据展示、用户交互、数据验证、界面设计等功能。
- 控制层(Controller)：负责接收并转发请求，对请求进行处理后，指定视图并将响应结果发送给客户端。
- 数据模型层(Model)：模型对象拥有最多的处理任务，是应用程序的主体部分，它负责数据逻辑(业务规则)的处理和实现数据操作(即在数据库中存取数据)。
案例
新建StudentView.cs、StudentModel.cs和StudentController.cs，分别作为视图层、数据模型层和控制层。
StudentView.cs
using UnityEngine;
public class StudentView
{
public void PrintStudentDetails(string studentName, string studentRollNo)
{
Debug.Log("Student: ");
Debug.Log("Name: " + studentName);
Debug.Log("Roll No: " + studentRollNo);
}
}StudentModel.cs
public class StudentModel
{
private string name;
private string rollNo;
public string Name { get => name; set => name = value; }
public string RollNo { get => rollNo; set => rollNo = value; }
}StudentController.cs
public class StudentController
{
private StudentModel model;
private StudentView view;
public StudentController(StudentModel model, StudentView view)
{
this.model = model;
this.view = view;
}
public void SetStudentName(string name)
{
model.Name = name;
}
public string GetStudentName()
{
return model.Name;
}
public void SetStudentRollNo(string rollNo)
{
model.RollNo = rollNo;
}
public string GetStudentRollNo()
{
return model.RollNo;
}
public void UpdateView()
{
view.PrintStudentDetails(model.Name, model.RollNo);
}
}新建MVCPatternDemo.cs，实现代码如下：
using UnityEngine;
public class MVCPatternDemo : MonoBehaviour
{
private void Awake()
{
StudentModel model = RetrieveStudentFromDatabase();
StudentView view = new StudentView();//创建一个视图：把学生详细信息输出到控制台
StudentController controller = new StudentController(model, view);
controller.UpdateView();
controller.SetStudentName("John");//更新模型数据
controller.UpdateView();
}
private static StudentModel RetrieveStudentFromDatabase()
{
StudentModel student = new StudentModel();
student.Name = "Robert";
student.RollNo = "10";
return student;
}
}输出如下：
观察者模式
概念
观察者模式(发布-订阅模式)属于行为型模式。在程序设计中，观察者模式通常由两个对象组成：观察者和被观察者。当被观察者状态发生改变时，它会通知所有的观察者对象，使他们能够及时做出响应。
优点
解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变化都不会影响另一边的变化。
缺点
在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。
组成
- 抽象被观察者(Subject)：定义了一个接口，包含了注册观察者、删除观察者、通知观察者等方法。
- 具体被观察者(ConcreteSubject)：实现了抽象被观察者接口，维护了一个观察者列表，并在状态发生改变时通知所有注册的观察者。
- 抽象观察者(Observer)：定义了一个接口，包含了更新状态的方法。
- 具体观察者(ConcreteObserver)：实现了抽象观察者接口，存储了需要观察的被观察者对象，并在被观察者状态发生改变时进行相应的处理。
过程
1.观察者(Observer)：
观察者将自己注册到被观察者中，被观察者将观察者存放在一个容器里。
2.被观察(Subject)：
被观察者发生变化时，从容器中得到所有注册过的观察者，将变化通知观察者。
3.撤销观察
观察者告诉被观察者要撤销观察，被观察者从容器中将观察者去除。
观察者将自己注册到被观察者的容器中时，被观察者不应该过问观察者的具体类型，而是应该使用观察者的接口。这样的优点是：假定程序中还有别的观察者，那么只要这个观察者也是相同的接口实现即可。一个被观察者可以对应多个观察者，当被观察者发生变化的时候，他可以将消息一一通知给所有的观察者。基于接口，而不是具体的实现，这一点为程序提供了更大的灵活性。
案例
新建ISubject.cs和IObserver.cs，分别作为抽象被观察者和抽象观察者。
新建ConcreteSubject.cs和ConcreteObserver.cs，分别作为具体被观察者和具体观察者。
脚本内容如下：
ISubject.cs
///
/// 抽象被观察者
///
public interface ISubject
{
///
/// 添加观察者
///
///
void AddObserver(IObserver observer);
///
/// 删除观察者
///
///
void RemoveObserver(IObserver observer);
///
/// 通知观察者
///
///
void NoticeObserver(string message);
}IObserver.cs
///
/// 抽象观察者
///
public interface IObserver
{
///
/// 更新消息
///
///
void UpdateMessage(string message);
}ConcreteSubject.cs
using System.Collections.Generic;
///
/// 具体被观察者
///
public class ConcreteSubject : ISubject
{
private List observers = new List();//存储观察者的容器
public void AddObserver(IObserver observer)
{
observers.Add(observer);
}
public void RemoveObserver(IObserver observer)
{
observers.Remove(observer);
}
public void NoticeObserver(string message)
{
for (int i = 0; i < observers.Count; i++)
{
observers[i].UpdateMessage(message);
}
}
} ConcreteObserver.cs
using UnityEngine;
///
/// 具体观察者
///
public class ConcreteObserver : IObserver
{
private string name;//观察者的名字
public ConcreteObserver(string name)
{
this.name = name;
}
public void UpdateMessage(string message)
{
Debug.Log(name + "---接到消息: " + message);
}
}新建一个MyObserver.cs，内容如下：
using UnityEngine;
public class MyObserver : MonoBehaviour
{
private void Awake()
{
ConcreteSubject concreteSubject = new ConcreteSubject();//定义一个主题
ConcreteObserver concreteObserver01 = new ConcreteObserver("李先生");//实例化一个观察者
ConcreteObserver concreteObserver02 = new ConcreteObserver("王女士");//实例化一个观察者
//李先生和王女士订阅该主题
concreteSubject.AddObserver(concreteObserver01);
concreteSubject.AddObserver(concreteObserver02);
concreteSubject.NoticeObserver("俄罗斯和乌克兰打起来了");//通知所有观察者(订阅者)
//王女士取消订阅该主题
concreteSubject.RemoveObserver(concreteObserver02);
concreteSubject.NoticeObserver("国际形势逐步紧张起来");//通知所有观察者(订阅者)
}
}最终输出如下：
