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

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

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

    /// <summary>
    /// 模板方法，给出逻辑骨架，逻辑的组成是相应的抽象操作
    /// 放到子类实现
    /// </summary>
    public void TemplateMethod()
    {
        PrimitiveOperation1();
        PrimitiveOperation2();
        Debug.Log("0");
    }
}

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

class ConcreteClassA : AbstractClass
{
    public override void PrimitiveOperation1()
    {
        Debug.Log("具体类A方法1实现");
    }

    public override void PrimitiveOperation2()
    {
        Debug.Log("具体类A方法2实现");
    }
}
class ConcreteClassB : AbstractClass
{
    public override void PrimitiveOperation1()
    {
        Debug.Log("具体类B方法1实现");
    }

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

客户端代码：

class Main : MonoBehaviour
{
    private void Start()
    {
        AbstractClass c;
        c = new ConcreteClassA();
        c.TemplateMethod();

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

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

使用实例：

abstract class AbstractClass 
{
    public abstract string PrimitiveOperation1();
    public abstract void PrimitiveOperation2();

    public void PassID()
    {
       Debug.Log("具体类方法1实现:" + PrimitiveOperation1());
    }
    
    public void TemplateMethod()
    {
        PrimitiveOperation2();
    }
}

class ConcreteClassA : AbstractClass
{
    public override string PrimitiveOperation1()
    { 
        return "A";
       
    }

    public override void PrimitiveOperation2()
    {
        Debug.Log("具体类A方法2实现");
    }
}
class ConcreteClassB : AbstractClass
{
    public override string PrimitiveOperation1()
    {
        return "B";
    }

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

class Main : MonoBehaviour
{
    private void Start()
    {
        AbstractClass c;
        c = new ConcreteClassA();
        c.TemplateMethod();
        c.PassID();

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

运行结果：