设计模式----模板方法模式

/**
 * @author 陈柏宇
 * 这个设计模式适合在这样的场景下使用:
 * 我们想输出一个相同问题的不同答案,那么这个时候只要答案不同就可以了,题目都是相同的
 * 所以我们就可以写一个父类,让这个父类在模板方法里写出题干,父类的抽象方法则是子类要去实现的功能
 *
 * 那么我们既然已经使用了继承,并且肯定这个继承有意义,父类就应该要成为子类的模板,所有重复的代码都应该
 * 上升到父类中去,而不是让每个子类都重复
 *
 * 我们再来介绍一下模板方法模式:
 * 定义一个操作中的算法的骨架,并且将一些步骤延迟到子类中去,模板方法让每个子类可以不改变一个算法的结构
 * 即可重新定义该算法的某些特定步骤
 *
 *
 */

模板方法模式简而言之就是提供了一种很好的代码复用平台,当不变的和可变的行为在方法子类实现中混合在一起的时候,不变得行为就会

在子类中重复出现,代码冗余,我们可以通过模板方法模式把不变的搬移到父类中去,通过继承帮助子类摆脱重复的不变行为的纠缠。

这其实在我的项目中也有体现。

我们先看看模板的UML类图:

父类代码:

/**
 * @author 陈柏宇
 * 模板,一切具体事物的父类
 */

public abstract class AbstractClass {
    /**
     * 类中的原始方法
     * 子类都一定要执行的但是都不同的方法
     */
    public abstract void primitiveOperation1();
    public abstract void primitiveOperation2();

    public void TemplateMethod()
    {
        primitiveOperation1();
        primitiveOperation2();
    }
}

子类A代码:

/**
 * @author 陈柏宇
 * 具体子类,继承AbstractClass类并且实现父类中的抽象方法
 *
 */

public class ConcreteClassA extends AbstractClass{

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

子类B代码:

/**
 * @author 陈柏宇
 * 具体子类B
 */

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

main函数:

public static void main(String[] args) {
        AbstractClass c;

        c = new ConcreteClassA();
        c.TemplateMethod();

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

控制台输出:

具体子类A方法1的实现
具体子类A方法2的实现
具体子类B方法1的实现
具体子类B方法2的实现

我们再来看一个具体的例子:

关于考试。

由于试题都是一样的,而不同的就是学生试卷上写的答案,所以如果我们直接写的话肯定会出现大量代码的冗余

这个时候就要用到我们的模板方法设计模式了:

试卷类:

public abstract class TestPaper {
    public abstract String answer1();

    public abstract String answer2();

    public abstract String answer3();

    public void question1()
    {
        System.out.println("试题1");
        System.out.println("答案:" + answer1());
    }

    public void question2()
    {
        System.out.println("试题2");
        System.out.println("答案:" + answer2());
    }

    public void question3()
    {
        System.out.println("试题3");
        System.out.println("答案:" + answer3());
    }
}

考生A类:

public class TestPaperA extends TestPaper{
    @Override
    public String answer1()
    {
        return "a";
    }
    @Override
    public String answer2()
    {
        return "a";
    }
    @Override
    public String answer3()
    {
        return "a";
    }
}

考生B类:

public class TestPaperB extends TestPaper{
    @Override
    public String answer1()
    {
        return "b";
    }
    @Override
    public String answer2()
    {
        return "b";
    }
    @Override
    public String answer3()
    {
        return "b";
    }
}

main函数:

public static void main(String[] args) {
        System.out.println("学生A的试卷:");
        TestPaper a;
        a = new TestPaperA();
        a.question1();
        a.question2();
        a.question3();

        System.out.println("学生B的试卷");
        TestPaper b;
        b = new TestPaperB();
        b.question1();
        b.question2();
        b.question3();
    }

控制台输出:

学生A的试卷:
试题1
答案:a
试题2
答案:a
试题3
答案:a
学生B的试卷
试题1
答案:b
试题2
答案:b
试题3
答案:b

对继承和多态玩的好的人几乎都会在继承体系中或多或少的使用它,这是一个非常常用的设计模式,希望大家掌握并多多使用!

 

posted @ 2021-09-06 22:38  Apak陈柏宇  阅读(56)  评论(0编辑  收藏  举报