模板模式

动机:对于某一项任务，它常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因，而无法和任务的整体结构同时实现。
例题：考试的例子，考试题相同每个人的解答不同
定义一个抽象类，将部分逻辑以具体方法以及具体子类实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同子类可以以不同的方式来实现这些抽象方法。
实现代码：

class TestPaper
{
    protected String Answer1()
    {
        return "";
    }
    protected String Answer2()
    {
        return "";
    }
    protected String Answer3()
    {
        return "";
    }
    public void TestQuestion1()
    {
        System.out.println("*****() a.* b.* c.* d.*");
        System.out.println("答案:"+Answer1());
    }
    public void TestQuestion2()
    {
        System.out.println("*****() a.* b.* c.* d.*");
        System.out.println("答案:"+Answer2());
    }
    public void TestQuestion3()
    {
        System.out.println("*****() a.* b.* c.* d.*");
        System.out.println("答案:"+Answer3());
    }
}
class TestPaperA extends TestPaper
{
    protected String Answer1()
    {
        return "b";
    }
    protected String Answer2()
    {
        return "c";
    }
    protected String Answer3()
    {
        return "a";
    }
}
class TestPaperB extends TestPaper
{
    protected String Answer1()
    {
        return "c";
    }
    protected String Answer2()
    {
        return "a";
    }
    protected String Answer3()
    {
        return "a";
    }
}//子类很简单，重写方法后把答案填上，因为父类建立了所以重复的模板
public class sheji
{
    public static  void main(String[] args)
    {
        System.out.println("学生甲抄的试卷:");
        //子类变量的声明改成父类，利用多态性，实现代码重用
        TestPaper sA=new TestPaperA();
        sA.TestQuestion1();
        sA.TestQuestion2();
        sA.TestQuestion3();
        System.out.println("学生乙抄的试卷:");

        TestPaper sB=new TestPaperA();
        sB.TestQuestion1();
        sB.TestQuestion2();
        sB.TestQuestion3();
        //此时若有更多的学生来答试卷，只不过是在试卷的模板上填写选择题的选项答案，这是每个人试卷的不同
    }
}

模板方法模式：定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。

模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

abstract class AbstractClass
{//一些抽象行为，放到子类中去实现
    public abstract void primitiveOperation1();
    public abstract void primitiveOperation2();
    //模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，他们都推迟到了子类实现
    public void TemplateMethod()
    {
        primitiveOperation1();
        primitiveOperation2();
        System.out.println("");
    }
}
class ConcreteClassA extends AbstractClass
{
    public void  primitiveOperation1()
    {
        System.out.println("具体类A方法1实现");
    }
    public void  primitiveOperation2()
    {
        System.out.println("具体类A方法2实现");
    }
}
class ConcreteClassB extends AbstractClass
{
    public void  primitiveOperation1()
    {
        System.out.println("具体类B方法1实现");
    }
    public void  primitiveOperation2()
    {
        System.out.println("具体类B方法2实现");
    }
}
public class sheji
{
    public static  void main(String[] args)
    {
AbstractClass c;
c=new ConcreteClassA();
c.TemplateMethod();
c=new ConcreteClassB();
c.TemplateMethod();
    }
}

模板方法模式是基于继承的代码复用的核心技术。模板方法模式的结构和用法也是面向对象设计的核心。

• 优点：实现代码的复用
• 缺点：算法骨架不容易升级