关于模版方法设计模式的疑问

1. abstract class GetTime//此类是获取某段代码运行的时间
   
2. {
   
3. public void getTime()
   
4. {
   
5. long start = System.currentTimeMillis();
   
6. 
   
7. /*for(int x = 0;x<1000;x++)
   
8. {
   
9. System.out.print(x);
   
10. }*/
    
11. runcode();
    
12. long end = System.currentTimeMillis();
    
13. System.out.println("毫秒："+(end-start));
    
14. }
    
15. public abstract void runcode();
    
16. 
    
17. /*
    
18. * 程序运行代码未知，只是获取时间的一种方式
    
19. {
    
20. for(int x=0;x<1000;x++)
    
21. {
    
22. System.out.println(x);
    
23. }
    
24. }*/
    
25. 
    
26. }
    
27. class SubTime extends GetTime
    
28. {
    
29. /*public void getTime()
    
30. {
    
31. long start = System.currentTimeMillis();
    
32. 
    
33. for(int x = 0;x<4000;x++)
    
34. {
    
35. System.out.print(x);
    
36. }
    
37. long end = System.currentTimeMillis();
    
38. System.out.println("毫秒："+(end-start));
    
39. }*/
    
40. 
    
41. //子继父类，只需要复写父类功能定义自己的特有功能
    
42. public void runcode()
    
43. {
    
44. for(int x = 0;x<4000;x++)
    
45. {
    
46. System.out.print(x);
    
47. }
    
48. }
    
49. }
    
50. public class TemplateDemo {
    
51. 
    
52. public static void main(String[] args) {
    
53. //GetTime gt = new GetTime();
    
54. SubTime gt = new SubTime();
    
55. gt.getTime();
    
56. 
    
57. }
    
58. 
    
59. }
    
60. 疑问：用这个模式能否求出视频运行时间，用代码怎么实现？求助。。。。。

复制代码

1. package my;
   
2. 
   
3. abstract class GetTime// 此类是获取某段代码运行的时间
   
4. {
   
5.         public void getTime() {
   
6.                 long start = System.currentTimeMillis();
   
7.                 runcode();
   
8.                 long end = System.currentTimeMillis();
   
9.                 System.out.println("耗时" + (end - start) + "毫秒：");
   
10.         }
    
11. 
    
12.         public abstract void runcode();
    
13. }
    
14. 
    
15. class SubTime extends GetTime {
    
16.         public void runcode(){};
    
17. }
    
18. 
    
19. public class TemplateDemo {
    
20. 
    
21.         public static void main(String[] args) {
    
22.                 SubTime gt = new SubTime() {
    
23.                         @Override
    
24.                         public void runcode() {
    
25.                               <font color="#ff0000"> System.out.println("程序开始:");
    
26.                                 try {
    
27.                                         Thread.sleep(3000);
    
28.                                 } catch (InterruptedException e) {
    
29.                                         e.printStackTrace();
    
30.                                 }
    
31.                                 System.out.println("程序结束");</font>
    
32.                         }
    
33.                 };
    
34.                 gt.getTime();
    
35.         }
    
36. }
    

复制代码

把主方法里的红色部分改成自己向运行的代码..
就可以统计了.这个使用的是内部类.重写runcode的方法.

模版方法设计模式
    规定一个体系，但是其中有的一部分需要用户自己去编写,其他的按部就班，这个体系就叫做模版设计模式,例如：一个类有一个模版，执行顺序是第一、第二 、第三 ，但是不知道第二怎么去执行，把这部分抽象出来，那个这个类也是抽象类了。子类在继承这个类时，只要实现第二个方法就可以了。其他的不做任何改变。
策略设计模式
　　自定义一个类，但是所有的功能都已经完成，返回结果是，不知道用户需要怎么样的结果，这个参数由用户调用这个类是用户自己传递，而自定义类时，只是将这个参数封装成一个接口，用户自己去实现，自己去定义返回什么样的结果。