程序員上班路上案例解說-工廠模式

設計模式相關文章

 

1、前言

一樣在上班的路上，一個程序員想着是買梅乾菜肉包仍是買酸辣粉絲包，到了包子點卻發現只有饅頭餡子的包子了，卻買了一包豆漿；

一個程序員可能在在家吃完飯開車去上班了，這尼瑪是富二代；

一個程序員可能想着如何把本身的代碼如何優化，如何提升性能，如何的如何……

上班路上的程序員讓你輕鬆瞭解三個設計模式

2、簡單工廠模式

簡單工廠模式(Simple Factory Pattern)：又稱爲靜態工廠方法(Static Factory Method)模式，它屬於類建立型模式。在簡單工廠模式中，能夠根據參數的不一樣返回不一樣類的實例。簡單工廠模式專門定義一個類來負責建立其餘類的實例，被建立的實例一般都具備共同的父類。

簡單工廠模式就比如一個是一個富二代程序員，你要什麼，簡單工廠就給你什麼。

簡單工廠模式包括三個角色：抽象產品角色，具體產品角色，工廠角色

代碼實現以下：

    //抽象產品角色：交通工具車
    public abstract class Car
    {
        public virtual void GoToWork()
        {
        }
    }

    //具體產品角色：自行車
    public class Bike : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("騎自行車去上班");
        }
    }
    //具體產品角色：公交車
    public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("作公交車去上班");
        }
    }
    //工廠角色：簡單工廠類
    public class SimpleFactory
    {
        public static Car CreateSimple(string str)
        {
            Car simple = null;
            switch (str)
            {
                case "Bike":
                    simple = new Bike();
                    break;
                case "Bus":
                    simple = new Bus();
                    break;
                //……
            }
            return simple;

        }
    }

客戶端調用代碼：

            //根據客戶端傳入的參數簡單工廠決定如何去上班
            Car car = SimpleFactory.CreateSimple("Bus");
            car.GoToWork();

 

3、工廠方法模式

工廠方法模式(Factory Method Pattern)又稱爲工廠模式，也叫虛擬構造器(Virtual Constructor)模式或者多態工廠(Polymorphic Factory)模式，它屬於類建立型模式。在工廠方法模式中，工廠父類負責定義建立產品對象的公共接口，而工廠子類則負責生成具體的產品對象，這樣作的目的是將產品類的實例化操做延遲到工廠子類中完成，即經過工廠子類來肯定究竟應該實例化哪個具體產品類。

工廠方法模式包括四個角色：抽象產品角色，具體產品角色，抽象工廠角色，具體工廠角色

具體示例代碼實現以下：

    //抽象產品角色：交通工具車
    public abstract class Car
    {
        public virtual void GoToWork()
        {
        }

    }

    //具體產品角色：自行車
    public class Bike : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("騎自行車去上班");
        }
    }
    //具體產品角色：公交車
    public class Bus : Car
    {
        public override void GoToWork()
        {
            Console.WriteLine("作公交車去上班");
        }
    }

    //抽象工廠角色：工廠接口
    public interface IFactory
    {
        Car ByWhatWay();
    }
    //具體工廠類：自行車類
    public class BikeFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bike();
        }
    }
    //具體工廠類：公交車類
    public class BusFactory : IFactory
    {
        public Car ByWhatWay()
        {
            return new Bus();
        }

    }

客戶端調用代碼：

 

            //根據客戶端實例化的工廠決定如何去上班
            IFactory factory = new BusFactory();   //常規寫法

            //反射優化  (BusFactory)Assembly.Load("當前程序集名稱").CreateInstance("當前命名空間名稱.要實例化的類名")
            //using System.Reflection; 引用命名空間
            //var factoryName = "BusFactory";
            //IFactory factory = (BusFactory) Assembly.Load("當前程序集名稱").CreateInstance("當前命名空間名稱." + factoryName);
            
            Car car = factory.ByWhatWay();
            car.GoToWork();

 

4、抽象工廠模式

抽象工廠模式(Abstract Factory Pattern)：提供一個建立一系列相關或相互依賴對象的接口，而無須指定它們具體的類。抽象工廠模式又稱爲Kit模式，屬於對象建立型模式。

抽象工廠模式包括四個角色：抽象產品角色，具體產品角色，抽象工廠角色，具體工廠角色

具體示例代碼以下：

//抽象交通工具車
    public abstract class Car
    {
        //名字
        public string CarName{ get; set; }
        public virtual string GoToWork()
        {
            return CarName;
        }

    }
    //抽象早飯類
    public abstract class BreakFast
    {
        //早飯名稱
        public string FoodName { get; set; }

        public virtual string Eat()
        {
            return FoodName;
        }
    }

    //自行車
    public class Bike : Car
    {
        public override string GoToWork()
        {
            CarName = "騎着自行車";
            return CarName;
        }
    }
    //公交車
    public class Suv: Car
    {
        public override string GoToWork()
        {
            CarName = "開着SUV汽車";
            return CarName;
        }
    }

    //高逼格早飯：三明治牛奶
    public class SandWichAndMilk : BreakFast
    {
        public override string Eat()
        {
            FoodName = "三明治和牛奶";
            return FoodName;
        }
    }
    
    //苦逼早飯：包子豆漿
    public class BaoziAndDoujiang : BreakFast
    {
        public override string Eat()
        {
            FoodName = "包子豆漿";
            return FoodName;
        }
    }

    //抽象工廠類
    public abstract class AbstractFactory
    {
        //建立交通工具方法
        public abstract Car CreatCar();

        //建立早飯方法
        public abstract BreakFast CreateBreakFast();

    }

    //具體工廠類：苦逼程序員
    public class LowFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Bike();
        }

        public override BreakFast CreateBreakFast()
        {
            return new BaoziAndDoujiang();
        }
    }
    //具體工廠類：高逼格程序員
    public class HighFactory : AbstractFactory
    {
        public override Car CreatCar()
        {
            return new Suv();
        }

        public override BreakFast CreateBreakFast()
        {
            return new SandWichAndMilk();
        }
    }

    public class CoderLove
    {
        private Car car;
        private BreakFast breakFast;
        public CoderLove (AbstractFactory fac)
        {
            car=fac.CreatCar();
            breakFast=fac.CreateBreakFast();
        }

        public void GetCoderLove()
        {
            Console.WriteLine("早飯吃完"+breakFast.Eat()+","+car.GoToWork()+"去上班");
        }
    }

客戶端調用：

            AbstractFactory factory=new HighFactory();
            CoderLove coder=new CoderLove(factory);
            coder.GetCoderLove();

抽象工廠模式隔離了具體類的生成，使得客戶並不須要知道什麼被建立。

因爲這種隔離，更換一個具體工廠就變得相對容易。全部的具體工廠都實現了抽象工廠中定義的那些公共接口，所以只需改變具體工廠的實例，就能夠在某種程度上改變整個軟件系統的行爲。

除了以上苦逼程序員，高逼格程序員，還能夠具體添加一個開車SUV吃着包子豆漿的具體工廠，也能夠添加騎着自行車吃着三明治牛奶的具體工廠。

5、總結

一、這個三個模式都屬於對象建立型模式

二、簡單工廠模式簡單的理解爲客戶端告訴工廠他想要什麼實例，工廠就給生產什麼實例

三、工廠方法模式能夠理解客戶端有了建立實例的機器，他想要什麼實例就本身生產什麼實例

四、抽象工廠模式最多見的狀況是一套程序須要多套數據實現的狀況下

 

示例代碼下載：https://yunpan.cn/cY8cctUs7pXSb （提取碼：157b）