Unity之设计模式：单例模式和对象池模式

1. 单例模式

单例模式原则：

1. 只能有一个实例。
2. 必须自己创建自己。
3. 必须给所有其他对象提供这一实例。

目的：第一条保证仅有一个实例（私有化构造函数），第二、三条保证提供一个访问它的全局访问点（提供一个供访问的公共方法/属性）。

优点：避免一个全局使用的类被频繁的创建与销毁。

 分类：饿汉式：不去new一个新的，而是在Awake里 instance=this。

懒汉式：需要用的时候，发现单例为空，再实例化一个。

public class SingleTon<T> : MonoBehaviour where T : Component
{
    private static T instance;
    public static T Instance //提供对外访问的属性
    {
        get
        {
            if (instance == null)  //如果没有实例化，那就实例化一个
            {
                if (FindObjectsOfType<T>().Length > 1)  //查找挂载了这个脚本的物体，如果超过1个，多个物体挂载了不符合单例模式
                    Debug.LogError("instance count>1");
                instance = FindObjectOfType<T>(); //挂载在一个物体身上了
                if (instance == null) //没有挂载在任何物体身上
                {
                    GameObject go = new GameObject(); //创建一个空物体
                    go.name = typeof(T).ToString();  //物体名就是类型名
                    instance = go.AddComponent<T>(); //把这个脚本挂载上去
                }
            }
            return instance;
        }
    }
}

 

 

2. 对象池模式

目的：需要频繁的创建和销毁的物体，比如怪兽、金币、障碍物... 频繁的创建和销毁非常耗费资源，不如游戏一开始就创建出来一堆，先隐藏起来，要使用的时候取消隐藏（从池子中取出），不使用了再隐藏（放回池子）。

 

案例：结合单例模式，做一个道具生成和销毁对象池。要求主池子掌控所有物体的生成和销毁（主池子只有一个），子池子提供共有的方法和特征（取出、放回）。

1）提前把道具的预制体做好，放在资源文件夹下。

 

 

 2）写子池子逻辑：从子池子中取出、放回子池子、放回所有物体

public class SubPool
{
    List<GameObject> subPool = new List<GameObject>();
    GameObject prefab;

    public SubPool(GameObject pref)
    {
        prefab = pref;
    }
    public GameObject OutPool() //从池子中取出
    {
        GameObject obj = null;
        foreach (GameObject go in subPool) //找到一个被隐藏的物体，取出来
        {
            if (go.activeSelf == false)
                obj = go;
        }
        if (obj == null)  //池子里没有被隐藏的物体了，预存的不够用了，再生成一个
        {
            obj = GameObject.Instantiate(prefab);
            subPool.Add(obj);  //把新生成的也加到池子里
        }
        obj.SetActive(true); //把找到的这个物体显示出来(取出来)
        return obj;
    }
    public void InputPool()  //放回池子中
    {
        if (subPool.Count > 0)
        {
            foreach(GameObject go in subPool)
            {
                if (go.activeSelf == true)
                {
                    go.SetActive(false);
                    break;
                }
            }
        }
    }
    public void InputAllObject()  
    {
        foreach (GameObject go in subPool)
        {
            if (go.activeSelf == true)
                InputPool();
        }
    }
}

3）写主池子逻辑，管理所有子池子。

public class ObjManager : SingleTon<ObjManager>
{
    private Dictionary<string, SubPool> PoolDic = new Dictionary<string, SubPool>();  //用字典掌管所有的子池子

    public GameObject OutPool(string name) 
    {
        if (PoolDic.ContainsKey(name) == false) //如果主池子不包含该对象，new一个子池子，添加进主池子中
        {
            GameObject obj = Resources.Load("Prefabs/" + name) as GameObject;
            SubPool subpool = new SubPool(obj);
            PoolDic.Add(name, subpool);
        }
        SubPool subPool = PoolDic[name];
        return subPool.OutPool();
    }
    public void InputPool(string objName)
    {
        PoolDic[objName].InputPool();
    }
    public void InputAllObject()
    {
        foreach (SubPool sp in PoolDic.Values)
            sp.InputAllObject();
    }
}