模板方法模式

 

模板方法模式

 

一、定义

       模板方法模式（TemplateMethod），定义一个操作中的算法骨架，而将一些步骤延迟到了子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

二、代码结构图

 

        AbstractClass类是抽象类，其实也是一个抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。

 abstract class AbstractClass
    {
        //一些抽象行为，放到子类去实现。
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        //模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它们都推迟到子类实现。
        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
    }

        ConcreteClass，实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应，而每一个ConcreteClass都可以给出这些抽象对象（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

class ConcreteClassA : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console .WriteLine ("具体类A方法1实现"); //与ConcreteClassB不同的实现方法
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类A方法2实现");
        }
    }

    class ConcreteClassB : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("具体类B方法1实现");  //与ConcreteClassA不同的实现方法
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("具体类B方法2实现");
        }
    }

        客户端调用

static void Main(string[] args)
        {
            AbstractClass c;

            c = new ConcreteClassA();
            c.TemplateMethod();

            c = new ConcreteClassB();
            c.TemplateMethod();

            Console.Read();
        }

三、模板方法模式的特点：

        模板方法模式是通过把不变行为搬移到超类，去除子类中的重复代码来体现它的优势。

四、应用场景：

        当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。

五、实例：考试试卷

       （一）考试试卷有两部分组成：试题+答案。每张试卷的试题是相同的，但是每一个的答案可能是不同的。

       （二）考试试卷代码结构图：

 

//试卷父类代码
    class TestPaper
    {
        public void TestQuestion1()
        {
            Console.WriteLine("杨过得到，后来给了郭靖，练成倚天剑、屠龙刀的玄铁可能是[] a.球磨铸铁 b.马口铁 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
            Console.WriteLine("答案是："+Answer1 ());
        }
        protected virtual string Answer1()
        {
            return "";
        }

        public void TestQuestion2()
        {
            Console.WriteLine("杨过、程英、陆无双铲除情花，造成[] a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
            Console.WriteLine("答案是："+Answer2 ());
        }
        protected virtual string Answer2()
        {
            return "";
        }

        public void TestQuestion3()
        {
            Console.WriteLine("蓝凤凰致使华山师徒、桃古六仙呕吐不止，如果你是大夫，会给他们开什么药[] a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的生牛奶 e.以上全不对");
            Console.WriteLine("答案是："+ Answer3());
        }
        protected virtual string Answer3()
        {
            return "";
        }
    }

    //学生甲抄的试卷
    class TestPaperA : TestPaper
    {
        protected override string Answer1()
        {
            return "b";
        }

        protected override string Answer2()
        {
            return "b";
        }

        protected override string Answer3()
        {
            return "b";
        }
    }

    //学生乙抄的试卷
    class TestPaperB : TestPaper
    {
        protected override string Answer1()
        {
            return "c";
        }

        protected override string Answer2()
        {
            return "a";
        }

        protected override string Answer3()
        {
            return "a";
        }
    }

        客户端调用：

static void Main(string[] args)
        {
            Console.WriteLine("学生甲抄的试卷：");
            TestPaper studentA = new TestPaperA();
            studentA.TestQuestion1();
            studentA.TestQuestion2();
            studentA.TestQuestion3();

            Console.WriteLine("学生乙抄的试卷：");
            TestPaper studentB = new TestPaperB();
            studentB.TestQuestion1();
            studentB.TestQuestion2();
            studentB.TestQuestion3();

            Console.Read();
        }

         客户端变量（studentA、studentB）的声明改成了父类，利用了多态性，实现了代码的复用。