簡單工廠模式

簡單工廠是工廠模式中比較簡單何容易理解的一種模式。簡單工廠模式其實就是用來建立不同型別的物件的。

程式碼：

public enum PhoneType {
    Apple = 1,
    XiaoMi,
    HuaWei,
}
public class SimpleFactroy : MonoBehaviour {

	void Start () {
        for (int i = 0; i < 10; i++)
        {
            int index = Random.Range(1, 4);
            IPhone phone = Factroy.CreatePhone((PhoneType)index);
            Debug.Log(phone.version());
        }
	}
}

public interface IPhone {
    string version();
}

public class ApplePhone : IPhone
{
    public string version()
    {
        return "蘋果";
    }
}

public class XiaoMiPhone : IPhone {
    public string version()
    {
        return "小米";
    }
}

public class HuaWeiPhone : IPhone {
    public string version()
    {
        return "華為";
    }
}

//把物件的建立過程和初始化過程移到了工廠中，使用時比較方便
public class Factroy {
    public static IPhone CreatePhone(PhoneType type) {
        switch (type) {
            case PhoneType.Apple:
                return new ApplePhone();
            case PhoneType.XiaoMi:
                return new XiaoMiPhone();
            case PhoneType.HuaWei:
                return new HuaWeiPhone();
            default:
                return null;
        }
    }
}
 

優點：

1、簡單易懂

2、邏輯清晰，就是根據不同的列舉型別建立不同的物件例項。

缺點：

違反了開閉原則，當對程式碼進行擴充套件時，需要對之前的程式碼進行改動。

工廠模式

工廠模式和簡單工廠的區別就是，工廠模式克服了簡單工廠的違反開閉原則，將工廠進行抽象，將實現邏輯延遲到工廠的子類當中。

程式碼：

 public class SimpleFactroy2 : MonoBehaviour
    {
        void Start()
        {
            AppleFactroy appleFac = new AppleFactroy();
            Debug.Log(appleFac.CreatePhone(1).version());
            Debug.Log(appleFac.CreatePhone(2).version());
            Debug.Log(appleFac.CreatePhone(3).version());

            XiaoMiFactroy miFactory = new XiaoMiFactroy();
            Debug.Log(miFactory.CreatePhone(3).version());
        }
    }

    public interface IPhone
    {
        string version();
    }

    public class ApplePhone : IPhone
    {
        public string version()
        {
            return "蘋果";
        }
    }

    public class XiaoMiPhone : IPhone
    {
        public string version()
        {
            return "小米";
        }
    }

    public class HuaWeiPhone : IPhone
    {
        public string version()
        {
            return "華為";
        }
    }

    public interface IFactroy {
        IPhone CreatePhone(int type);
    }

    public class AppleFactroy : IFactroy {
        public IPhone CreatePhone(int type) {
            return new ApplePhone();
        }
    }

    public class XiaoMiFactroy : IFactroy {
        public IPhone CreatePhone(int type) {
            return new XiaoMiPhone();
        }
    }

    public class HuaWeiFactroy : IFactroy {
        public IPhone CreatePhone(int type)
        {
            return new HuaWeiPhone();
        }
    }
 

優點：

1、整體程式碼結構清晰，職責單一。

2、可擴充套件性和穩定性提高

缺點：

當增加新的產品的時候，就會怎加一個新的類，程式碼的複雜程度提高了。

抽象工廠

抽象工廠和工廠模式的區別就是在工廠模式的基礎上增加了產品族這個感念，也就是說抽象工廠用來生成一系列產品時是更好的。

程式碼：

public class SimpleFactroy3 : MonoBehaviour
    {
        void Start()
        {
            IFactory apple = new AppleFactory();
            Debug.Log(apple.CreateBook(1).bookVersion());
            Debug.Log(apple.CreatePhone(1).version());

            IFactory huawei = new HuaWeiFactory();
            Debug.Log(huawei.CreateBook(1).bookVersion());
            Debug.Log(huawei.CreatePhone(1).version());
        }
    }

    public interface IPhone
    {
        string version();
    }
    public interface IBook
    {
        string bookVersion();
    }

    public class ApplePhone : IPhone
    {
        public string version()
        {
            return "蘋果手機";
        }
    }
    public class AppleBook : IBook
    {
        public string bookVersion()
        {
            return "蘋果電腦";
        }
    }
    public class XiaoMiPhone : IPhone
    {
        public string version()
        {
            return "小米手機";
        }
    }
    public class XiaoMiBook : IBook
    {
        public string bookVersion()
        {
            return "小米電腦";
        }
    }
    public class HuaweiPhone : IPhone
    {
        public string version()
        {
            return "華為手機";
        }
    }
    public class HuaweiBook : IBook
    {
        public string bookVersion()
        {
            return "華為電腦";
        }
    }

    public interface IFactory
    {
        IPhone CreatePhone(int type);
        IBook CreateBook(int type);
    }
    //蘋果品牌
    public class AppleFactory : IFactory
    {
        public IPhone CreatePhone(int type)
        {
            return new ApplePhone();
        }
        public IBook CreateBook(int type)
        {
            return new AppleBook();
        }
    }
    //小米品牌
    public class XiaoMiFactory : IFactory
    {
        public IPhone CreatePhone(int type)
        {
            return new XiaoMiPhone();
        }
        public IBook CreateBook(int type)
        {
            return new XiaoMiBook();
        }
    }
    //華為品牌
    public class HuaWeiFactory : IFactory
    {
        public IPhone CreatePhone(int type)
        {
            return new HuaweiPhone();
        }
        public IBook CreateBook(int type)
        {
            return new HuaweiBook();
        }
    }
 

優點：

可以使我們很輕鬆的就增加了一系列產品的實現。

缺點：

不適合產品的橫向擴充套件，當我們需要增加產品時，就需要去修改基類，違反開閉原則。