简单工厂,抽象工厂,对象池

简单工厂示例

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

public class SimpleFactoryTest : MonoBehaviour {

	// Use this for initialization
	void Start () {
        //简单工厂模式     
        //通过不同的类型  产生或者返回  相对应的对象
        //继承    抽象   接口
        //MobilePhone mobilePhone = MobilePhoneFactory.CreateMobilePhone(PhoneType.Iphone);
        //mobilePhone.Print();
        //上传具体手机类型
        MobilePhone xiaomiMobilePhone = MobilePhoneFactory.CreateMobilePhone(PhoneType.XiaoMI);
        xiaomiMobilePhone.Print();//调用实现类方法

    }
	
	// Update is called once per frame
	void Update () {
		
	}
}

/// <summary>
/// 抽象类
/// </summary>
public abstract class MobilePhone
{
    public abstract void Print();
}
/// <summary>
/// 实现类
/// </summary>
public class Iphone : MobilePhone
{
    public override void Print()
    {
        Debug.Log("我是苹果手机");
    }
}
public class XiaoMi : MobilePhone
{
    public override void Print()
    {
        Debug.Log("我是小米手机");
    }
}
public class Smratisan : MobilePhone
{
    public override void Print()
    {
        Debug.Log("我是锤子手机");
    }
}
/// <summary>
/// 枚举
/// </summary>
public enum PhoneType
{
    Iphone,
    XiaoMI,
    Smratisan,
}
public class MobilePhoneFactory
{
    /// <summary>
    /// 外部传过来一个手机类型
    /// </summary>
    /// <returns>返回一部手机的对象</returns>
    public static MobilePhone CreateMobilePhone(PhoneType type)
    {
        MobilePhone mobilePhone = null;
        switch (type)
        {
            case PhoneType.Iphone:
                mobilePhone = new Iphone();
                break;
            case PhoneType.XiaoMI:
                mobilePhone = new XiaoMi();
                break;
            case PhoneType.Smratisan:
                mobilePhone = new Smratisan();
                break;
            default:
                break;
        }
        return mobilePhone;
    }
}

抽象工厂

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

public class AbstractFactoryTest : MonoBehaviour {

	// Use this for initialization
	void Start () {

        AbstractFactory xiaomiFactory= new XiaomiFactory();
        MotherBoard motherBoard = xiaomiFactory.CreateMotherBoard();
        motherBoard.Print();
        Screen screen = xiaomiFactory.CreateScreen();
        screen.Print();
	}
	
	// Update is called once per frame
	void Update () {
		
	}
}
/// <summary>
/// 抽象工厂类
/// </summary>
public abstract class AbstractFactory
{
    public abstract Screen CreateScreen();
    public abstract MotherBoard CreateMotherBoard();
}
/// <summary>
/// 抽象屏幕类
/// </summary>
public abstract class Screen
{
    public abstract void Print();
}
/// <summary>
/// 抽象主板类
/// </summary>
public abstract class MotherBoard
{
    public abstract void Print();
}

public class AppleScreen : Screen
{
    public override void Print()
    {
        Debug.Log("苹果手机屏幕");
    }
}
public class XiaoMiScreen : Screen
{
    public override void Print()
    {
        Debug.Log("小米屏幕");
    }
}
public class AppleMotherBoard : MotherBoard
{
    public override void Print()
    {
        Debug.Log("苹果主板");
    }
}
public class XiaoMiMotherBoard : MotherBoard
{
    public override void Print()
    {
        Debug.Log("小米主板");
    }
}
public class AppleFactory : AbstractFactory
{
    public override MotherBoard CreateMotherBoard()
    {
        return new AppleMotherBoard();
    }

    public override Screen CreateScreen()
    {
        return new AppleScreen();
    }
}
public class XiaomiFactory : AbstractFactory
{
    public override MotherBoard CreateMotherBoard()
    {
        return new XiaoMiMotherBoard();
    }

    public override Screen CreateScreen()
    {
        return new XiaoMiScreen();
    }
}

对象池

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

public class ObjectPool : MonoBehaviour {
    //monster的模板
    public GameObject mMonster;
    //monster的对象池
    private Stack<GameObject> monsterPool;
    //在当前场景中正在使用的  激活的monster
    private Stack<GameObject> activeMonsterPool;
    // Use this for initialization
    void Start () {
        monsterPool = new Stack<GameObject>();
        activeMonsterPool = new Stack<GameObject>();
	}
	
	// Update is called once per frame
	void Update () {
        if (Input.GetMouseButtonDown(0))
        {
            //获取一个monster对象
            GameObject monster = GetMonster();
            monster.transform.position = Vector3.zero;
            activeMonsterPool.Push(monster);
        }
        if (Input.GetMouseButtonDown(1))
        {
            if (activeMonsterPool.Count>0)
            {
                PushGameObjectToPool(activeMonsterPool.Pop());
            }
        }
	}
    /// <summary>
    /// 获取一个monster
    /// </summary>
    /// <returns></returns>
    private GameObject GetMonster()
    {
        GameObject monster = null;

        if (monsterPool.Count > 0)
        {
            //池子中有对象
            monster = monsterPool.Pop();
            monster.SetActive(true);
        }
        else {
            //对象池中没有对象
            monster = Instantiate(mMonster);
        }
        return monster;
    }

    private void PushGameObjectToPool(GameObject monster)
    {
        monster.transform.SetParent(transform);
        monster.SetActive(false);
        monsterPool.Push(monster);
    }
}