模板方法

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。因此模板方法使得子类可以在不改变一个算法的结构的情况下重新定义该算法的某些特定变量。优点：把不变行为搬移到超类，去除子类中的重复代码。

C#实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication15
{
    abstract class abstractTemplateMethod
    {
        public abstract void Method1();
        public abstract void Method2();

        public void Handle()
        {
            Method1();
            Method2();
        }
    }

    class ContreteMethodA : abstractTemplateMethod
    {
        public override void Method1()
        {
            Console.WriteLine("MethodA-1");
        }
        public override void Method2()
        {
            Console.WriteLine("MethodA-2");
        }
    }

    class ContreteMethodB : abstractTemplateMethod
    {
        public override void Method1()
        {
            Console.WriteLine("MethodB-1");
        }
        public override void Method2()
        {
            Console.WriteLine("MethodB-2");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            abstractTemplateMethod atm = new ContreteMethodA();
            atm.Handle();
            abstractTemplateMethod atm1 = new ContreteMethodB();
            atm1.Handle();
            Console.Read();
        }
    }
}

python实现

class abstractTemplateMethod:

    def __init__(self):
        pass
    
    def Handle(self):
        print (self.Method1())
        print (self.Method2())

    def Method1(self):
        return none

    def Method2(self):
        return none

class ContreteMethodA(abstractTemplateMethod):
    def Method1(self):
        return 'MethodA-1'

    def Method2(self):
        return 'MethodA-2'

class ContreteMethodB(abstractTemplateMethod):
    def Method1(self):
        return 'MethodB-1'

    def Method2(self):
        return 'MethodB-2'

atm = ContreteMethodA();
atm.Handle()

atm1 = ContreteMethodB();
atm1.Handle()