模板模式，程序员的一天

        首先简单描述一下我工作（Android程序员）的一天，7点起床洗漱，9点打卡上班，上午写Android代码，12点吃午餐，下午1点到6点写Android代码，6点下班，如果需求紧急就要加班到晚上八点。接下来我描述一下我同事（Java程序员）的一天，8点起床洗漱，九点打卡上班，上午写java代码，12点吃午饭，下午1点到6点写java代码，6点下班，如果需求紧急就要加班到晚上八点。我们的一天好像被人安排好了，起床、打卡上班、写代码、吃午饭、写代码、下班（但也可能加班）。像是一个的模版固定的生活步骤，只是起床时间和写什么代码不同罢了。

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

案例分析：固定的生活步骤就是算法的骨架，而起床时间和写代码就是可以重新定义的某些特定步骤。

优点：控制算法，封装不变，拓展可变

注意：分清哪些是不变，哪些是可变。

代码：首先定义模板类

public abstract class Programmer {

    //程序员姓名
    protected String name;

    public Programmer(String name) {
        this.name = name;
    }

    //起床
    public void getUp() {
        System.out.println(name + "6点起床上班");
    }

    //九点打卡上班
    public final void punchCard(){
        System.out.println(name + "9点打卡上班");
    }

    //工作
    public abstract void work();

    //午餐
    public void lunch(){
        System.out.println(name + "吃午餐");
    }

    //下班
    public final void offDuty() {
        System.out.println("下午6点，下班时间到");
    }

    //回家
    public final void goHome() {
        System.out.println(name+"回家");
    }

    //是否加班（钩子方法）
    public boolean isOverTime() {
        return false;
    }

    //加班到晚上八点
    public void overTime() {
        System.out.println(name + "需要加班到晚上八点才能下班");
    }

    /**
     * 程序员的一天(模板方法,子类不可重写)
     */
    public final void oneDay() {
        getUp();//起床
        punchCard();//打卡
        work();//写代码
        lunch();//吃中午饭
        work();//写代码
        offDuty();//下班
        if (isOverTime()) {//是否要加班
            overTime();//加班到八点
            goHome();//加完班回家
        }else {
            goHome();//回家
        }
    }
}

两个实现类：一个Android程序员、一个Java程序员

public class AndroidProgrammer extends Programmer {

    public AndroidProgrammer(String name) {
        super(name);
    }

    @Override
    public void getUp() {
        System.out.println(name + "7点起床上班");
    }

    @Override
    public void work() {
        System.out.println(name + "写Android代码");
    }
}

public class JavaProgrammer extends Programmer {

    public JavaProgrammer(String name) {
        super(name);
    }

    @Override
    public void getUp() {
        System.out.println(name + "8点起床上班");
    }

    @Override
    public void work() {
        System.out.println(name + "写java代码");
    }

    @Override
    public boolean isOverTime() {
        System.out.println("Java需求紧急");
        return true;
    }
}

测试类：

public class Test {

    public static void main(String args[]) {
        Programmer zuowei = new AndroidProgrammer("佐为");
        zuowei.oneDay();

        System.out.println("============================");

        JavaProgrammer zongjie = new JavaProgrammer("宗介");
        zongjie.oneDay();

        System.out.println("============================");
    }

}

结果：

佐为7点起床上班
佐为9点打卡上班
佐为写Android代码
佐为吃午餐
佐为写Android代码
下午6点，下班时间到
佐为回家
============================
宗介8点起床上班
宗介9点打卡上班
宗介写java代码
宗介吃午餐
宗介在工作，编写java程序
下午6点，下班时间到
Java需求紧急 
宗介需要加班到晚上八点才能下班
宗介回家
============================

这里讲一下钩子方法，默认程序员是不加班isOverTime()返回false。当子类重写钩子方法isOverTime()并返回ture，才执行加班步骤。通俗讲钩子方法就是控制特定步骤要不要执行。