（27）模块方法模式（理解抽象、继承和final）

需求：获取一段程序的运行时间

原理：获取程序开始和结束的时间并相减即可

获取时间：java.lang.System类中的currentTimeMills()静态方法，返回值为long类型的当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。

第一想法：将待测时间代码块放在开始时间和结束时间之间

public class getTime {public void getTime() {long start=System.currentTimeMillis();for(int i=0;i<1000;i++)//代码块               {System.out.print(i);}long end=System.currentTimeMillis();System.out.println();System.out.println("毫秒："+(end-start));}}public class getTimeDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub         getTime gt=new getTime();        gt.getTime();    }}

这种思考方式把待测时间代码块放在开始时间和结束时间之间，如果要计算代码运行时间，就得对代码改动，而且在代码里面改更难。这时，可以通过继承，进行方法复写，具体实现如下：

public class getTime {public void getTime() {long start=System.currentTimeMillis();for(int i=0;i<1000;i++)//代码块               {System.out.print(i);}long end=System.currentTimeMillis();System.out.println();System.out.println("毫秒："+(end-start));}                  } 
          public class subgetTime extends getTime{             public void getime(){//复写                
               long start=System.currentTimeMillis();for(int i=0;i<10000;i++)//代码块               {System.out.print(i);}long end=System.currentTimeMillis();System.out.println();System.out.println("毫秒："+(end-start));

} 
}


这样虽然能够完成，但是代码重复率太高，只是代码块发生了变化，其他都没变。既然是代码块变化，我们可以把代码块单独放置，然后让getTime()方法调用代码块方法。还需通过继承，具体如下：

public class getTime {public void getTime() {long start=System.currentTimeMillis();runCode();System.out.println("毫秒："+(end-start));}        public void runCode(){         
                for(int i=0;i<1000;i++)//代码块               {System.out.print(i);}
 }


 }
          public class subgetTime extends getTime{             public void runCode(){//复写                
for(int i=0;i<10000;i++)//代码块               {System.out.print(i);}

} 
}
public class getTimeDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub         subetTime gt=new subgetTime();        gt.getTime();    }}

其实父类中的runCode()方法内的方法体，写着也多余，因为代码的不确定性


public class getTime {public void getTime() {long start=System.currentTimeMillis();runCode();System.out.println("毫秒："+(end-start));}        public void runCode(){                     } }          public class subgetTime extends getTime{             public void runCode(){//复写                for(int i=0;i<10000;i++)//代码块               {System.out.print(i);}                 } }public class getTimeDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub         subetTime gt=new subgetTime();        gt.getTime();    }}

这个时候，runCode()方法，在getTime类中显得多余了。这时想到抽象方法，抽象类。

public abstract class getTime {public void getTime() {long start=System.currentTimeMillis();runCode();System.out.println("毫秒："+(end-start));}        public abstract void runCode()；                      }          public class subgetTime extends getTime{             public void runCode(){//通过继承，对抽象类中的抽象方法复写                for(int i=0;i<10000;i++)//代码块               {System.out.print(i);}                 } }public class getTimeDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub         subetTime gt=new subgetTime();        gt.getTime();    }}

这样，就优化了代码。重=从上面的代码可以看出，getTime()方法，就是获取代码运行时间的代码，不应该再改变（不能设为私有，私有只在类内可以使用，类外继承不可见），所以将这个方法改为final,不允许继承修改此代码

public abstract class getTime {public final void getTime() {long start=System.currentTimeMillis();runCode();System.out.println("毫秒："+(end-start));}        public abstract void runCode()； }          public class subgetTime extends getTime{             public void runCode(){//通过继承，对抽象类中的抽象方法复写                for(int i=0;i<10000;i++)//代码块               {System.out.print(i);}                 } }public class getTimeDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub         subetTime gt=new subgetTime();        gt.getTime();    }}


当代码优化后，就可以解决这类问题。
这种方式，模板方法设计模式。
什么事模板式方法呢？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分。
那么这时就将不确定的部分暴露出来，由该类的子类去完成。但不一定用抽象，有些含默认的实现。