设计模式-（单例模式）

确认类只有一个对象，并提供一个全局的方法来获取这个对象。在实现时，需要程序设计语言的支持。只要具有静态类属性，静态类方法和重新定义类建造者存取层级。

Singleton
1.能过产生唯一对象的类，并且提供”全局方法“让外界可以方便获取唯一的对象。
2.通常会把唯一的类对象设置为”静态类属性“。
3.习惯上使用Instance作为全局静态方法的名称。

涉及的代码为BaseDefenseGame ， BattleState

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BaseDefenseGame 
{
    //单例实现
    private static BaseDefenseGame _instance;
    public static BaseDefenseGame Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new BaseDefenseGame();
            }
            return _instance;
        }
    }
    private DefenseSystem defenseSystem = null;  //植物系统
    private EnemySystem enemySystem = null;      //僵尸系统
    private SunSystem sunSystem = null;          //太阳系统
    private MoneySystem moneySystem = null;      //金币系统

    public void Init()
    {
        defenseSystem = new DefenseSystem();
        enemySystem = new EnemySystem();
        sunSystem = new SunSystem();
        moneySystem = new MoneySystem();
    }

    public void Update()
    {
        defenseSystem.Update();
        enemySystem.Update();
        sunSystem.Update();
        moneySystem.Update();
    }

    public void Release()
    {
        efenseSystem.Release();
        enemySystem.Release();
        sunSystem.Release();
        moneySystem.Release();
    }

    //获取太阳的数量
    public int GetSunNum()
    {
        if (sunSystem != null)
        {
            return sunSystem.GetSunNumber();
        }
        return 0;
    }

}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class BattleState : ISceneState
{
    private SceneContext sceneContext;
    public BattleState(SceneContext sceneContext):base(sceneContext)
    {
        this.sceneContext = sceneContext;
    }

    public override void SceneBegin()
    {
        BaseDefenseGame.Instance.Init();
    }

    public override void SceneEnd()
    {
       BaseDefenseGame.Instance.Release();
    }


    public override void SceneUpdate()
    {
        BaseDefenseGame.Instance.Update();
    }
}

不过在后续处理中，可以创建一个抽象类。

using UnityEngine;

public abstract class SingletonMonoBehaviour : MonoBehaviour where T : SingletonMonoBehaviour
{
    private static T _instance;

    private static object _lock = new object();

    private static bool applicationIsQuitting = false;

    public static T Instance
    {
        get
        {
            if (applicationIsQuitting)
            {
                Debug.LogWarning("[SingletonMonoBehaviour] Instance '" + typeof(T) +
                                 "' already destroyed on application quit." +
                                 " Won't create again - returning null.");
                return null;
            }

            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = (T)FindObjectOfType(typeof(T));

                    if (FindObjectsOfType(typeof(T)).Length > 1)
                    {
                        Debug.LogError("[SingletonMonoBehaviour] Something went really wrong " +
                                       " - there should never be more than 1 singleton!" +
                                       " Reopenning the scene might fix it.");
                        return _instance;
                    }

                    if (_instance == null)
                    {
                        GameObject singletonMonoBehaviour = new GameObject();
                        _instance = singletonMonoBehaviour.AddComponent();
                        singletonMonoBehaviour.name = "(SingletonMonoBehaviour) " + typeof(T).ToString();
                    }
                }

                return _instance;
            }
        }
    }

    public void OnDestroy()
    {
        applicationIsQuitting = true;
    }
}

public abstract class Singleton where T : new()
{
    private static T _instance;
    private static object mutex = new object();
    public static T instance
    {
        get
        {
            if (_instance == null)
            {
                lock (mutex)
                {
                    if (_instance == null)
                    {
                        _instance = new T();
                    }
                }
            }
            return _instance;
        }
    }
}

单例模式的优点：可以限制对象的产生数量，提供方便获取唯一对象的方法。
单例模式的缺点：容易造成设计思考不周和过度使用的问题，其次违法开一闭原则。通过Instance方法获取对象是”实现类“而不是”接口类“，该方法返回的对象包含了细节的实体类，所以当设计变更或者需求增加时，程序设计无法将其替代为其他类，只能更改原有实现类内的程序代码，所以无法满足”对修改关闭的要求“。不过让其返回接口类（即父类为单例模式类型，子类继承实现），可以通过以下措施来解决。1.子类向父类注册实体对象，让父类的Instance返回对象，按条件查表返回对应的子类对象。2.每个子类都实现单例模式，再由父类的Instance去获取这些子类。