设计模式—模板方法

引用博客链接： http://www.cnblogs.com/wangjq/archive/2012/07/09/2582978.html

1. 模板方法

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

2. 角色

       2.1  抽象类：实现了模板方法，定义了算法的骨架。

       2.2  具体类：实现抽象类中的抽象方法，已完成完整的算法。

3.  模式解读：

         3.1  类图

         

  3.2  代码

        

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

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

    /// <summary>
    /// 具体类，实现了抽象类中的特定步骤
    /// </summary>
    public class ConcreteClassA : AbstractClass
    {
        /// <summary>
        /// 与ConcreteClassB中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("Implement operation 1 in Concreate class A.");
        }

        /// <summary>
        /// 与ConcreteClassB中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("Implement operation 2 in Concreate class A.");
        }
    }

    /// <summary>
    /// 具体类，实现了抽象类中的特定步骤
    /// </summary>
    public class ConcreteClassB : AbstractClass
    {
        /// <summary>
        /// 与ConcreteClassA中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("Implement operation 1 in Concreate class B.");
        }

        /// <summary>
        /// 与ConcreteClassA中的实现逻辑不同
        /// </summary>
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("Implement operation 2 in Concreate class B.");
        }
    }

3.3 客户端代码

 class Program
    {
        static void Main(string[] args)
        {
            // 声明抽象类
            AbstractClass c;

            // 用ConcreteClassA实例化c
            c = new ConcreteClassA();
            c.TemplateMethod();

            // 用ConcreteClassB实例化c
            c = new ConcreteClassB();
            c.TemplateMethod();

            Console.Read();
        }
    }

 

      4 总结

             4.1 优点：

                     4.1.1   把不变的共用的代码搬迁到超类中，去除了子类中重复的代码。

                     4.1.2   子类中实现算法的某些细节，有助于算法的扩展

                     4.1.3    通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合开闭原则。

             4.2 缺点：

                    4.2.1  每个不同的实现都需要定义一个子类，导致类的个数的增加，设计更加抽象。

             4.3 适用场景：

                    4.3.1 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。即“重分解以一般化”，首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这                                 些新的操作的模板方法来替换这些不同的代码。

                    4.3.2  一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。