一、基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽
象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

二、模板设计模式能解决的问题

1)当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

2)编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式

三、最佳实践

一、AA类

package com.hspedu.abstract_;


public class AA{

    //计算任务
    //1+2+...+80000
    public void job(){
        long start = System.currentTimeMillis();
        int num = 0;
        for (int i = 1; i <= 80000; i++) {
            num += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("AA耗时" + (end - start));

    }
   
}

调用System中的currentTimeMillis，返回当前时间（以毫秒为单位）

二、BB类

package com.hspedu.abstract_;


public class BB{

   //计算任务
    //1*2+...*1000000
    public void job(){
        long start = System.currentTimeMillis();
        int num = 0;
        for (int i = 1; i <= 1000000; i++) {
            num *= i;
        }
        long end = System.currentTimeMillis();
        System.out.println("BB耗时" + (end - start));

    }
   
}

三、main方法实现

package com.hspedu.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.job();
        BB bb = new BB();
        bb.job();
    }
}

四、提取相同语句

package com.hspedu.abstract_;


public class AA{
    public void calculateTime(){
        long start = System.currentTimeMillis();
        job();
        long end = System.currentTimeMillis();
        System.out.println("AA耗时" + (end - start));
    }
    //计算任务
    //1+2+...+80000
    public void job(){
        int num = 0;
        for (int i = 1; i <= 80000; i++) {
            num += i;
        }

    }
   
}

package com.hspedu.abstract_;


public class BB{
    public void calculateTime(){
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        long end = System.currentTimeMillis();
        System.out.println("BB耗时" + (end - start));
    }
   //计算任务
    //1*2+...*1000000
    public void job(){
      
        int num = 0;
        for (int i = 1; i <= 1000000; i++) {
            num *= i;
        }
       

    }
   
}

package com.hspedu.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
        BB bb = new BB();
        bb.calculateTime();
    }
}

五、建立继承关系

父类-Template

package com.hspedu.abstract_;

abstract public class Template {
    public void calculateTime(){
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - start));
    }
    abstract public void job();
}

父类中没有实现job方法的必要，将其设置成abstract方法，在子类中根据子类的需求重写

子类-AA类

package com.hspedu.abstract_;


public class AA extends Template{

    //计算任务
    //1+2+...+80000

    @Override
    public void job() {
        long num = 0;
        for (long i = 1; i <= 80000; i++) {
            num += i;
        }
    }
}

子类-BB类

package com.hspedu.abstract_;

public class BB extends Template{

    //计算任务
    //1*2+...*1000000

    @Override
    public void job() {
        long num = 0;
        for (long i = 1; i <= 1000000; i++) {
            num *= i;
        }
    }
}

package com.hspedu.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
        BB bb = new BB();
        bb.calculateTime();
    }
}

六、运行中的动态绑定机制

上述代码中的 aa.calculateTime();根据动态绑定机制，aa的运行类型是AA，所以首先从AA类中调用calculateTime()方法，但是AA类中没有calculateTime()方法，根据继承的查找原则，向上查找其父类-Template类

public void calculateTime(){
    long start = System.currentTimeMillis();
    job();//动态绑定机制
    long end = System.currentTimeMillis();
    System.out.println("耗时" + (end - start));
}
abstract public void job();

按照代码顺序依次运行，运行到job();时，仍然遵循动态绑定机制的规则，根据其运行类型调用job()方法，所以调用AA类中的job()方法

bb.calculateTime()同理