第08章雷鋒依然在人間－－工廠方法模式

8.2 簡單工廠模式實現

class OperationFactory

{

    public static Operation createOperate(string operate)

    {

        Operation Oper = null;

        switch (operate)

        {

            case “+”:

                oper = new OperationAdd();

                break;

            case “-“:

                oper = new OperationSub();

                break;

            case “*”:

                oper = new OperationMul();

                break;

            case “/“

                oper = new OperationDiv();

                break;

        }

        return oper;

    }

}

客戶端的應用

Operation oper;

oper = OperationFactory.createOperate(“+”);

oper.NumberA = 1;

oper.NumberB = 2;

double result = oper.GetResult();

8.3 工廠方法模式實現

先構建一個工廠介面：

interface IFactory

{

    Operation CreateOperation();

}

然後加減乘除各建一個具體工廠去實現這個介面。

class AddFactory : IFactory

{

    public Operation CreateOperation()

    {

        return new OperationAdd();

    }

}

class SubFactory : IFactory

{

    public Operation CreateOperation()

    {

        return new OperationSub();

    }

}

class MulFactory : IFactory

{

    public Operation CreateOperation()

    {

        return new OperationMul();

    }

}

class DivFactory : IFactory

{

    public Operation CreateOperation()

    {

        return new OperationDiv();

    }

}

客戶端的實現是這樣的：

IFactory operFactory ＝ new AddFactory();

Operation oper = operFactory.CreateOperation();

oper.NumberA = 1;

oper.NumberB = 2;

double result = oper.GetResult();

8.4 簡單工廠VS工廠方法

    簡單工廠模式的最大優點在於工廠類中包含了必要的邏輯判斷，根據客戶端的選擇條件動態例項化相關的類，對於客戶端來說，去除了與具體產品的依賴。但簡單工廠不但對擴充套件開放，也對修改開放，這違背了開放封閉原則。

    我們講過，既然這個工廠類與分支耦合，那麼我們就對他下手，根據依賴倒轉原則，我們把工廠類抽象出一個介面，這個介面只有一個方法，就是建立抽象產品的工廠方法。然後，所有的要生產具體類的工廠，就去實現這個介面，這樣，一個簡單工廠模式的工廠類，就變成了一個工廠抽象介面和多個具體生成物件的工廠，當我們需要增加新的功能時，就不需要更改原有的工廠類了，只需要增加此功能的運算類和相應的工廠類就可以了。

    這樣整個工廠和產品體系其實都沒有修改的變化，而只是擴充套件的變化，這就完全符合了開放－封閉原則的精神。

    工廠方法模式實現時，客戶端需要決定例項化哪一個工廠來實現運算類，選擇判斷的問題還是存在的，也就是說，工廠方法把簡單工廠的內部邏輯判斷移動到了客戶端程式碼來執行。你想要加功能，本來是該工廠類的，而現在是修改客戶端。

8.5 雷鋒工廠

//雷鋒

class LeiFeng

{

    public void Sweep()

    {

        Console.WriteLine(“掃地”);

    }

    public void Wash()

    {

        Console.WriteLine(“洗衣”);

    }

    public void BuyRice()

    {

        Console.WriteLine(“買米”);

    }

}

//學雷鋒的大學生

class Undergraduate : LeiFeng

{ }

//客戶端實現

Leiteng xueleifeng = new Undergraduate();

xueleifeng.BuyRice();

xueleifeng.Sweep();

xueleifeng.Wash();

//如果是有三個人學雷鋒

Leiteng xueleifeng1 = new Undergraduate();

xueleifeng1.BuyRice();

Leiteng xueleifeng2 = new Undergraduate();

xueleifeng2.Sweep();

Leiteng xueleifeng3 = new Undergraduate();

xueleifeng3.Wash();

//社群志願者

class Volunteer : LeiFeng

{ }

//簡單雷鋒工廠

class SimpleFactory

{

    public static LeiFeng CreateLeiFeng(string type)

    {

        LeiFeng result = null;

        switch (type)

        {

            case “學雷鋒的大學生”:

                result = new Undergraduate();

                break;

            case “社群志願者”:

                result = new Volunteer();

                break;

        }

        return result;

    }

}

//簡單工廠模式

LeiFeng studentA = SimpleFactory.CreateLeiFeng(“學雷鋒的大學生”);

studentA.BuyRice();

LeiFeng studentB = SimpleFactory.CreateLeiFeng(“學雷鋒的大學生”);

studentB.Sweep();

LeiFeng studentC = SimpleFactory.CreateLeiFeng(“學雷鋒的大學生”);

studentC.Wash();

此時你就發現，你需要在任何例項化的時候寫出這個工廠的程式碼。這裡有重複，也就有了壞味道。再用工廠方法模式寫一遍：

//雷鋒工廠

interface IFactory

{

    LeiFeng CreateLeiFeng();

}

//學雷鋒的大學生工廠

class UndergraduateFactory : IFactory

{

    public LeiFeng CreateLeiFeng()

    {

        return new Undergraduate;

    }

}

//社群自願者工廠

class VolunteerFactory : IFactory

{

    public LeiFeng CreateLeiFeng()

    {

        return new Volunteer();

    }

}

客戶端呼叫的時候只需要這樣就可以一了。

//工廠方法模式

IFactory factory = new UndergraduateFactory();

LeiFeng student = factory.CreateLeiFeng();

student.BuyRice();

student.Sweep();

student.Wash();

現在如果需要修改的話只需要修改一處就可以了。利用反射技術可以做到更好。