一、定义(只能通过继承来实现, 使用覆盖实现微调)

模板方法模式(Template Method Pattern) 通常又叫模板模式, 是指定义一个算法的骨架, 并允许子类成为其中的一个或者多个步骤提供实现.

模板方法使得子类可以在不改变算法结构的情况下, 重新定义算法的某些步骤.

属于行为型设计模式.

二、使用场景

1. 一次性实现一个算法不变的部分, 并将可变的行为留给子类来实现.
2. 各子类中公共的行为被提取出来并集中到一个公共的父类中, 从而避免代码重复.

三、Java代码简单写法

使用三个类简单表述

/**
 * 1. 程抽象类, 用于统一课程的特性, 设置了一个钩子方法用于是否'检查作业'步骤
 */
public abstract class AbastractCourse {
    
    public final void createCourse(){
        //1、发布预习资料
        postPreResoucse();
        
        //2、制作课件
        createPPT();
        
        //3、直播授课
        liveVideo();
        
        //4、上传课后资料
        postResource();
        
        //5、布置作业
        postHomework();
        
        //6、检查作业, 我们可以交给子类实现, 可能每个课程检查作业方式不一样
        //(也可能不需要检查作业), 我们可以交给用户自己来决定是否检查作业 
        if(needCheckHomework()){
            checkHomework();
        }
    }

    protected abstract void checkHomework();

    //钩子方法
    protected boolean needCheckHomework(){return  false;}

    protected void postHomework(){
        System.out.println("布置作业");
    }

    protected void postResource(){
        System.out.println("上传课后资料");
    }

    protected void liveVideo(){
        System.out.println("直播授课");
    }

    protected void createPPT(){
        System.out.println("制作课件");
    }

    protected void postPreResoucse(){
        System.out.println("发布预习资料");
    }

/**
 * 2. Java课程实现类, 该类我们可以自定义决定是否可以'检查作业'的步骤
 */
public class JavaCourse extends AbastractCourse {
    private boolean needCheckHomework = false;

    public void setNeedCheckHomework(boolean needCheckHomework) {
        this.needCheckHomework = needCheckHomework;
    }

    @Override
    protected boolean needCheckHomework() {
        return this.needCheckHomework;
    }

    protected void checkHomework() {
        System.out.println("检查Java作业");
    }
}

/**
 * 3. ython课程实现类
 */
public class PythonCourse extends AbastractCourse {
    protected void checkHomework() {
        System.out.println("检查Python作业");
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        System.out.println("=========Java课程=========");
        JavaCourse java = new JavaCourse();
        // 设置java需要检查作业
        java.setNeedCheckHomework(true);
        java.createCourse();


        System.out.println("=========Python课程=========");
        PythonCourse python = new PythonCourse();
        python.createCourse();
    }
}

测试结果

---------------------------------------------

=========Java课程=========
发布预习资料
制作课件
直播授课
上传课后资料
布置作业
检查Java作业
=========Python课程=========
发布预习资料
制作课件
直播授课
上传课后资料
布置作业

---------------------------------------------

四、优点

1. 利用模板方法将相同处理逻辑的代码放到抽象父类中, 可以提高代码的复用性, 也符合开闭原则.
2. 将不同代码放到不同子类中, 通过对子类的扩展增加新的行为, 提高代码的扩展性.

五、缺点

1. 类数目的增加, 每一个抽象类都需要一个子类来实现, 这样导致类的个数增加.
2. 类数量的增加, 间接的增加了系统实现的复杂度.
3. 继承关系自身缺点, 如果父类添加新的抽象方法, 所有子类都需要改一遍.