模板方法模式templeteMethod

引出模板模式：

考试试卷问题，提炼后的代码：

package com.disign.templetemethod;

import org.junit.Test;

/**
 * Created by zhen on 2017-05-17.
 */
public class TestPaper {
    String name;
    public void setName(String name){
        this.name = name;
    }
    public TestPaper(){}
    public void testQuestionA(){
        System.out.println("1+1=? a.2 b.3 c.4 d.5");
        System.out.println("答案：" + answerA());
    }
    public void testQuestionB(){
        System.out.println("1*1=? a.1 b.2 c.3 d.4");
        System.out.println("答案：" + answerB());
    }
    public void testQuestionC(){
        System.out.println("1-1=? a.0 b.1 c.2 d.3");
        System.out.println("答案：" + answerC());
    }

    public String answerA(){
        return null;
    }
    public String answerB(){
        return null;
    }
    public String answerC(){
        return null;
    }

    public void show(){
        System.out.println(name + "的试题！");
        testQuestionA();
        testQuestionB();
        testQuestionC();
    }

    @Test
    public void testQuestion(){
        TestPaper studentA = new TestPaperA();
        studentA.setName("A");
        TestPaper studentB = new TestPaperB();
        studentB.setName("B");
        studentA.show();
        studentB.show();
    }
}
class TestPaperA extends TestPaper{
    public TestPaperA(){}

    @Override
    public String answerA() {

        return "a";
    }

    @Override
    public String answerB() {
        return "a";
    }

    @Override
    public String answerC() {
        return "a";
    }
}
class TestPaperB extends TestPaper{
    public TestPaperB(){}

    @Override
    public String answerA() {
        return "b";
    }

    @Override
    public String answerB() {
        return "b";
    }

    @Override
    public String answerC() {
        return "b";
    }
}

这里就用到了模板方法模式。

模板方法模式：

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

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

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

模板方法模式的特点：

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

　　模板方法模式提供了一个很好的代码复用平台

　　当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现，我们使用模板方法模式，帮助子类摆脱重复的不变行为的纠缠。