模板方法模式（七）

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

下面以一个试卷的例子说明模板方法模式：
有一个试卷类TestPaper，其中包含了试题：

/**
 * 考试试卷
 */
public class TestPaper {
    public void testQuestion1(){
        System.out.println("testQuestion1");
    }
    public void testQuestion2(){
        System.out.println("testQuestion2");
    }
    public void testQuestion3(){
        System.out.println("testQuestion3");
    }
}

两个学生（TestPaperA，TestPaperB）分别拿到该试卷进行答题：

/**
 * 学生A的试卷
 */
public class TestPaperA extends TestPaper {
    @Override
    public void testQuestion1() {
        super.testQuestion1();
        System.out.println("答案：A");
    }

    @Override
    public void testQuestion2() {
        super.testQuestion2();
        System.out.println("答案：B");
    }

    @Override
    public void testQuestion3() {
        super.testQuestion3();
        System.out.println("答案：A");
    }
}


/**
 * 学生B的试卷
 */
public class TestPaperB extends TestPaper {
    @Override
    public void testQuestion1() {
        super.testQuestion1();
        System.out.println("答案：A");
    }

    @Override
    public void testQuestion2() {
        super.testQuestion2();
        System.out.println("答案：B");
    }

    @Override
    public void testQuestion3() {
        super.testQuestion3();
        System.out.println("答案：C");
    }
}

客户端代码，输出考试结果：

public class TestPaperTest {
    public static void main(String[] args) {
        TestPaperA studentA = new TestPaperA();
        System.out.println("学生A考试答案");
        studentA.testQuestion1();
        studentA.testQuestion2();
        studentA.testQuestion3();

        TestPaperB studentB = new TestPaperB();
        System.out.println("学生B考试答案");
        studentB.testQuestion1();
        studentB.testQuestion2();
        studentB.testQuestion3();
    }
}

OutPut：

学生A考试答案
testQuestion1
答案：A
testQuestion2
答案：B
testQuestion3
答案：A

学生B考试答案
testQuestion1
答案：A
testQuestion2
答案：B
testQuestion3
答案：C

通过上面例子可以看出，学生A和学生B的试卷非常类似，除了答案不同，没什么不一样的，我们既然用到了继承，并且肯定这个继承有意义，就应该要成为子类的模板，所有重复的代码都应该上升到父类去，而不是让每个子类都重复。

这时就可以使用模板方法模式优化代码结构。当我们要完成在某一细节层次一致的一个过程或者一系列步骤，但其个别步骤在更详细的层次上的实现可能不同时，我们通常考虑使用模板方法模式来处理。

下面使用模板方法模式优化代码：

/**
 * 考试试卷
 */
public abstract class TestPaper {
    public void testQuestion1(){
        System.out.println("testQuestion1");
        System.out.println("答案：" + answer1());
    }
    public void testQuestion2(){
        System.out.println("testQuestion2");
        System.out.println("答案：" + answer2());
    }
    public void testQuestion3(){
        System.out.println("testQuestion3");
        System.out.println("答案：" + answer3());
    }
    public abstract String answer1();
    public abstract String answer2();
    public abstract String answer3();
}


/**
 * 学生A的试卷
 */
public class TestPaperA extends TestPaper {
    @Override
    public String answer1() {
        return "A";
    }

    @Override
    public String answer2() {
        return "B";
    }

    @Override
    public String answer3() {
        return "A";
    }
}


/**
 * 学生B的试卷
 */
public class TestPaperB extends TestPaper {
    @Override
    public String answer1() {
        return "A";
    }

    @Override
    public String answer2() {
        return "B";
    }

    @Override
    public String answer3() {
        return "C";
    }
}

客户端代码，输出考试结果：

public class TestPaperTest {
    public static void main(String[] args) {
        TestPaper studentA = new TestPaperA();
        System.out.println("学生A考试答案");
        studentA.testQuestion1();
        studentA.testQuestion2();
        studentA.testQuestion3();

        TestPaper studentB = new TestPaperB();
        System.out.println("学生B考试答案");
        studentB.testQuestion1();
        studentB.testQuestion2();
        studentB.testQuestion3();
    }
}

输出结果同上。

以上代码使用模板方法模式优化了代码，使得子类只填写答案，这也正是每个人试卷的不同之处。

模板方法模式组成：

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

public abstract class AbstractClass {
    /**
     * 操作1，由具体子类实现
     */
    public abstract void primitiveOperation1();

    /**
     * 操作2，由具体子类实现
     */
    public abstract void primitiveOperation2();

    /**
     * 模板方法，给出了逻辑骨架，而逻辑的组成是一些相应的抽象操作，它们都推迟到子类实现
     */
    public void templateMethod(){
        primitiveOperation1();
        primitiveOperation2();
    }
}

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

public class ConcreteClassA extends AbstractClass {
    @Override
    public void primitiveOperation1() {
        System.out.println("ConcreteClassA.primitiveOperation1");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("ConcreteClassA.primitiveOperation2");
    }
}


public class ConcreteClassB extends AbstractClass {
    @Override
    public void primitiveOperation1() {
        System.out.println("ConcreteClassB.primitiveOperation1");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("ConcreteClassB.primitiveOperation2");
    }
}

客户端代码：

public class TemplateTest {
    public static void main(String[] args) {
        AbstractClass c;
        c = new ConcreteClassA();
        c.templateMethod();

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

模板方法模式特点：

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

什么时候用：

模板方法模式就是提供了一个很好的代码复用平台。因为有时候我们会遇到一系列步骤购成的过程需要执行。这个过程从高层次上看是相同的，但有些步骤的实现可能不同。这时候，我们通常就应该考虑用模板方法模式了。
当不变的和可变的行为在方法的子类实现中混合到一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。
在Java类库的设计中，通常都会利用模板方法模式提取类库中的公共行为到抽象类中。

源码地址：https://gitee.com/nisen6477/design-patterns.git