1.行为模式：模板方法模式

今天学习了模板方法模式，这个设计方法非常适合学习设计模式刚入门的，它主要的方式是改善父类与子类之间的耦合度，增强代码的复用性。最重要的是让刚入门的懂得面向父类编程这个思想。废话不多说开搞！！！！
1.定义
1.1.问题：我们在设计一个系统时，在知道某个它的算法关键步骤，而且知道了这些步骤的执行顺序，但这些步骤具体的方法未知。
1.2定义：再编写一个程序时知道了这个类中的方法的执行顺序，在父类中确定一个算法骨架(通常理解是方法的执行顺序),再讲这些方法的具体实现就给其子类。从而实现方法的多态性。
1.3以下是模板方法模式类的方法定义：
1.3.1.抽象类：负责给出一个算法的轮廓或骨架（方法的执行顺序）
1.3.1.1.模板方法：定义了算法骨架，按某种顺序调用了其包含的基本方法
1.3.1.2.基本方法：是实现算法骨架中的具体步骤，包含了三种方法:
13.1.2.1.抽象方法:交给子类去具体实现
13.1.2.2.具体方法:在父类中实现的方法
13.1.2.3.钩子方法:判断算法骨架的逻辑，一般用boolean类型
1.3.2…具体子类
实现完成父类交给自己的方法
看下面理解
2.例子，代码，UML图
2.1：一个打工人一天的一天生活是起床，刷牙，吃早饭，工作，吃晚饭，睡觉。在这些生活步骤中起床，刷牙，睡觉是每个打工人一样的。但另外三个就不一样了，该吃什么早饭，我是什么职业该做什么工作，吃的什么晚饭。这些都是因人而异的，可以把他交由给它的子类。看下面角色
2.2角色：
Worker抽象类*：它扮演了一个抽象打工人类，定义了起床，刷牙，吃早饭，工作，吃晚饭，睡觉方法，其中吃早饭，工作，吃晚饭为抽象方法，最后在定义一个run()方法表示一天的生活步骤（即确定算法骨架的方法）。
Teacher类：定义了一个老师类，用于具体实现吃早饭，工作，吃晚饭方法。
Programmer类：定义了一个程序员类，用于具体实现吃早饭，工作，吃晚饭方法
上图:

代码区：

//抽象打工人类
public abstract class Worker {
    String workName;//工作者名字

    public Worker(String workName) {
        this.workName = workName;
    }

    public String getWorkName() {
        return this.workName;
    }

    public void setWorkName(String workName) {
        this.workName = workName;
    }

    //算法骨架（重中之重）
    public final void run(){
        this.getup();//起床
        this.brush();//刷牙
        this.breakfast();//吃早饭
        this.work();//工作
        this.sup();//吃晚饭
        this.sleep();//睡觉
    }

    //1.起床
    public void getup(){
        System.out.println(this.workName+"起床啦");
    }
    //2.刷牙
    public void brush(){
        System.out.println(this.workName+"刷牙啦");
    }
    //3.吃早饭
    public abstract void breakfast();
    //4.工作
    public abstract void work();
    //5.吃晚饭
    public abstract void sup();
    //6.睡觉
    public void sleep(){
        System.out.println(this.workName+"睡觉啦");
    }

}

//老师类
public class Teacher extends Worker {

    public Teacher(String workName) {
        super(workName);
    }

    @Override
    public void breakfast() {//吃早饭
        System.out.println(this.workName+"今天吃了米饭");
    }

    @Override
    public void work() {
        System.out.println(this.workName+"我一天都在教书");
    }

    @Override
    public void sup() {
        System.out.println(this.workName+"晚饭吃了米粥");
    }
}

//程序员类
public class Programmer extends Worker{

    public Programmer(String workName) {
        super(workName);
    }

    @Override
    public void breakfast() {//吃早饭
        System.out.println(this.workName+"今天喝了粥，吃了油条");
    }

    @Override
    public void work() {
        System.out.println(this.workName+"我一天都在敲代码");
    }

    @Override
    public void sup() {
        System.out.println(this.workName+"晚饭吃了汉堡儿");
    }
}

//测试类
public class test {
    public static void main(String[] args) {
        Worker w1 = new Programmer("程序员张三");
        w1.run();
        System.out.println("--------------------------------------------");
        Worker w2 = new Teacher("教师李四");
        w2.run();
    }
}

3.优缺点
优点：
1.提高了代码的复用性，因为是父类继承子类，相同代码放入父类中，不同实现的代码放入子类中。
2.实现了反向控制：这是一个父类调用子类的操作，根据不同的子类调用不同的实现方法。
缺点：
1.父类的抽象方法由子类，子类执行结果会影响父类结果，这导致一种反向的控制结构，提高了代码的阅读难度。

4.结语
这个设计模式和单例模式适合刚刚入门的，提高面向父类抽象的编程思维。