zoukankan      html  css  js  c++  java
  • 设计模式之模板方法模式(封装算法)

    第一次设计

    下面,我们的学习将从咖啡和茶的制作上开始进行。
    泡咖啡的步骤:

    • 把水煮沸
    • 用沸水冲泡咖啡
    • 把咖啡倒入杯子
    • 加糖和牛奶

    泡茶的步骤:

    • 把水煮沸
    • 用沸水侵泡茶叶
    • 把茶倒入杯子
    • 加柠檬

    下面,用代码来实现上面的步骤:
    咖啡的实现:

    public class Coffee
        {
            void prepareRecipe()
            {
                boilWater();
                brewCoffeeGrinds();
                pourInCup();
                addSugarAndMilk();
            }
    
            public void boilWater()
            {
                Console.WriteLine("Boiling water");
            }
    
            public void brewCoffeeGrinds()
            {
                Console.WriteLine("Dripping Coffee through filter");
            }
    
            public void pourInCup()
            {
                Console.WriteLine("Pouring into cup");
            }
    
            public void addSugarAndMilk()
            {
                Console.WriteLine("Adding Sugar and milk");
            }
        }
    

    茶的实现:

    public class Tea
        {
            void prepareRecipe()
            {
                boilWater();
                brewTeaBag();
                addLemon();
                pourInCup();
            }
    
            public void boilWater()
            {
                Console.WriteLine("Boiling water");
            }
    
            public void brewTeaBag()
            {
                Console.WriteLine("Steeping the tea");
            }
            public void pourInCup()
            {
                Console.WriteLine("pouring into cup");
            }
    
            public void addLemon()
            {
                Console.WriteLine("Adding Lemon");
            }
    
    
        }
    

    改进

    从上面的代码可以发现,有两个步骤我们是重复了的,我们可以把重复的部分抽取出来,放入到一个基类中。
    把boilWater()、pourInCup()提取出来放入基类,把prepareRecipe()定义成抽象方法。但这样定义,对于prepareRecipe()仍然需要实现两次,我们将boilWater()、pourInCup()泛化,使用brew()和addCondiments()来替代,并且在基类中,将其定义成抽象方法。这样prepareRecipe()不在抽象,而是在基类中实现。
    基类:

        public abstract class CaffeineBeverage
        {
            public void prepareRecipe()
            {
                boilWater();
                brew();
                addCondiments();
                pourInCup();
            }
    
            public void boilWater()
            {
                Console.WriteLine("Boiling water");
            }
    
            public void pourInCup()
            {
                Console.WriteLine("pouring into cup");
            }
    
            public abstract void brew();
    
            public abstract void addCondiments();
        }
    

    下面看一幅图,来看看我们现在都做了些什么:

    什么是模板方法

    模板方法定义了一个算法的步骤,并允许子类为一个或多个步骤提供实现
    在上面的代码中,我们模板方法就是prepareRecipe(),原因:

    • 它是一个方法
    • 它用作一个算法模板,在这个例子中,算法是用来制作咖啡因饮料
    • 在这里模板中,算法内的每一个步骤都被一个方法代表了。

    定义模板方法模式

    模板方法模式:在一个方法定义一个算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤

    这个抽象类包含了模板方法。
    primitiveOperation1()、primitiveOperation2()模板方法所用到的操作的抽象版本,模板方法本身和这两个操作的具体实现之间被解耦。
    一个模板方法中可能许多具体类,这个具体类实现了抽象类的操作。

    钩子(对模板方法进行挂钩)

    钩子是一种被声明在抽象类中的方法,但只有空的或者默认的实现。钩子的存在,可以让子类有能力对算法的不同点进行挂钩。要不要挂钩,由子类决定。
    下面来看看代码怎么写:

        public abstract class CaffeineBeverageWithHook
        {
            void prepareRecipe()
            {
                boilWater();
                brew();
                poueInCup();
                if (customerWantsCondiments())
                {
                    addCondiments();
                }
            }
            public abstract void brew();
            public abstract void addCondiments();
            void boilWater()
            {
                Console.WriteLine("Boiling water");
            }
            void poueInCup()
            {
                Console.WriteLine("Pouring into cup");
            }
            bool customerWantsCondiments()//这就是一个钩子,子类可以覆盖(这个方法通常是空的实现)
            {
                return true;
            }
        }
    

    使用钩子

    让我们看看它在实际代码里面的应用
    子类继承:

        public class CoffeeWithHook : CaffeineBeverageWithHook
        {
            public override void addCondiments()
            {
               Console.WriteLine("Adding Sugar through filter");
            }
            public override void brew()
            {
               Console.WriteLine("Dripping Coffee through filter");
            }
            public override bool customerWantsCondiments()
            {
                Console.WriteLine("Adding Sugar through filter?Y/N");
                string s = Console.ReadLine();
                if (s=="y")
                {
                    return true;
                }
                return false;
            }
        }
    

    测试:

            static void Main(string[] args)
            {
                CoffeeWithHook coffeewithhool=new CoffeeWithHook();
                coffeewithhool.prepareRecipe();
                Console.ReadKey();
            }
    

    关于钩子

    什么时候使用钩子

    当算法的某个实现可选的时候,可以使用钩子。当算法的某个实现是必须的时候,使用抽象方法

    钩子的目的

    钩子可以让子类有能力为其基类做一些决定。

    好莱坞原则

    好莱坞原则:别调用我们,我们会调用你。
    好莱坞原则防止依赖腐败:当高层组件依赖底层组件,而底层组件又依赖高层组件,而高层组件又依赖边测组件,边侧组件又依赖高层组件,这样依赖腐败就发生了。
    在好莱坞原则下,我们允许底层组件将自己挂钩到系统上,但高层组件会决定什么时候调用这些底层组件。

    好莱坞原则应用

    我们在之前设计模板方法的时候,其实就用到了好莱坞原则:

    在上面图中,CaffeineBeverage就是我们的高层组件,它能够控制冲泡方法的算法,只有在需要子类实现某个方法是才调用,饮料的客户代码只依赖CaffeineBeverage的抽象,而不依赖具体的类。

    好莱坞原则和依赖倒置原则

    在这里我们看到好莱坞原则感觉和依赖倒置原则很像,都是用于解耦。
    依赖倒置原则让我们尽量避免使用具体类,而多使用抽象,它更加注重与在设计中避免依赖。
    好莱坞原则则是一种用在创建框架或组件上的一种技巧,好让底层组件能够被挂钩计算,而又不会让高层组件依赖底层组件,它是创建一个有弹性的设计,允许底层结构能够互相操作,而又防止太过于依赖。

    使用模板方法来排序

    使鸭子类继承至IComparable接口,之后使用sort方法进行排序

        public class Duck:IComparable
        {
            private string name;
            private int weight;
            public Duck(string name, int weight)
            {
                this.name = name;
                this.weight = weight;
            }
            public  string toString()
            {
                return name + "weighs" + weight;
            }
            public int CompareTo(object obj)//需要提供的实现
            {
                Duck otherDuck = (Duck) obj;
    
                if (this.weight<otherDuck.weight)
                {
                    return -1;
                }
                else if (this.weight==otherDuck.weight)
                {
                    return 0;
                }
                else
                {
                    return 1;
                }
            }
        }
    

    排序

            static void Main(string[] args)
            {
                List<Duck> ducks=new List<Duck>{new Duck("11",11),new Duck("2",2),new Duck("13",13),new Duck("7",7)};
                DisPlay(ducks);
                ducks.Sort();
                DisPlay(ducks);
                Console.ReadKey();
            }
    

    在上面的例子中,我们可以看到子类提供的实现排序方法的算法。

  • 相关阅读:
    11_listview入门
    10_上午回顾&数据库事务
    09_sqlite两种api比较
    08_通过谷歌封装的api操作数据库update&query
    微软宣布下一代集成开发环境 — Visual Studio 2019
    微软宣布下一代集成开发环境 — Visual Studio 2019
    Chrome 调试技巧
    Chrome 调试技巧
    Chrome 调试技巧
    程序员最喜欢说的十句话,看看你最喜欢说哪句?
  • 原文地址:https://www.cnblogs.com/Tan-sir/p/8310899.html
Copyright © 2011-2022 走看看