-模板模式

模板模式：

定义

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

解决

一些方法通用，却在每一个子类都重新写成了方法。我们将这些通用方法抽象出来，让其在子类中实现。

优点

• 封装不变部分到父类，扩展可变部分，提供代码复用平台。
• 提取公共代码部分便于维护。
• 行为由父类控制，子类实现。

缺点

• 不同的实现需要不同的类，导致类数目庞大。

结构

模板模式包含如下角色：

• AbstractClass: 抽象父类
• ConcreteClass: 具体类
  

实现

package templatemethod;

public abstract class AbstractClass {
    public abstract void primitiveOperation1();

    public abstract void primitiveOperation2();

    public void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        System.out.println("");
    }
}

package templatemethod;

public class ConcreteClassA extends AbstractClass{
    @Override
    public void primitiveOperation1() {
        System.out.println("具体类A的方法1实现");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("具体类A的方法2实现");
    }
}

package templatemethod;

public class ConcreteClassB extends AbstractClass{
    @Override
    public void primitiveOperation1() {
        System.out.println("具体类B的方法1实现");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("具体类B的方法2实现");
    }
}

package templatemethod;

public class TemplateClient {
    public static void main(String[] args) {
        AbstractClass template;

        template = new ConcreteClassA();
        template.templateMethod();

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

实例

有一份试题，而学生做试题只有答案不同。那么就把答案这一块代码封装起来。

package templatemethod.demo;

//试题试卷：抽象类
public abstract class TestPaper {
    public void Q1()
    {
        System.out.println("1+1=___ \na)1\tb)2\tc)3\td)4");
    }
    public void Q2()
    {
        System.out.println("1+2=___ \na)1\tb)2\tc)3\td)4");
    }
    public void Q3()
    {
        System.out.println("2+2=___ \na)1\tb)2\tc)3\td)4");
    }

    protected String a1()
    {
        return "";
    }
    protected String a2()
    {
        return "";
    }
    protected String a3()
    {
        return "";
    }
}

package templatemethod.demo;
//学生A的试卷，具体类
public class PaperA extends TestPaper{
    @Override
    protected String a1()
    {
        return "a";
    }
    @Override
    protected String a2()
    {
        return "b";
    }
    @Override
    protected String a3()
    {
        return "c";
    }
}

package templatemethod.demo;
//学生B的试卷，具体类
public class PaperB extends TestPaper{
    @Override
    protected String a1()
    {
        return "b";
    }
    @Override
    protected String a2()
    {
        return "c";
    }
    @Override
    protected String a3()
    {
        return "d";
    }
}

package templatemethod.demo;

/**
 * 有一份试题，而学生做试题只有答案不同。
 * 那么就把答案这一块代码封装起来。
 */
public class TemplateClient {
    public static void main(String[] args) {

        TestPaper sA=new PaperA();
        TestPaper sB=new PaperB();
        System.out.println("A的试卷：");
        sA.Q1();
        sA.Q2();
        sA.Q3();
        System.out.println();
        System.out.println("B的试卷：");
        sB.Q1();
        sB.Q2();
        sB.Q3();

        System.out.println("A的答案：");
        System.out.println(sA.a1()+"\t"+sA.a2()+"\t"+sA.a3());
        System.out.println();
        System.out.println("B的答案：");
        System.out.println(sB.a1()+"\t"+sB.a2()+"\t"+sB.a3());
    }
}

总结

• 模板方法的核心思想是：父类定义骨架，子类实现某些细节。
• 为了防止子类重写父类的骨架方法，可以在父类中对骨架方法使用final。对于需要子类实现的抽象方法，一般声明为protected，使得这些方法对外部客户端不可见。
• Java标准库也有很多模板方法的应用。在集合类中，AbstractList和AbstractQueuedSynchronizer都定义了很多通用操作，子类只需要实现某些必要方法。