毕老师的第七天的视频中有个《模板方法模式》里讲到这样一段代码：

1. /*
   
2. 需求：获取一段程序运行时间
   
3. 原理：获取程序开始的时间和结束的时间并相减，即得程序运行的时间
   
4. 获取时间：System.currentTimeMillis();
   
5. */
   
6. 
   
7. class GetTime
   
8. {
   
9.       public void getTime()
   
10.       {
    
11.            long start = System.currentTimeMillis();
    
12.            runcode();
    
13.            long end = System.currentTimeMillis();
    
14.            System.out.println("时间为：" + (end - start));
    
15.       }
    
16.         
    
17.      public void runcode()
    
18.     {
    
19.          for (int i=0;i<1000;i++)
    
20.         {
    
21.              System.out.print("i1=" + i);
    
22.          }
    
23.                
    
24.     }
    
25. }
    
26. 
    
27. class SubTime extends GetTime
    
28. {
    
29.      public void runcode()
    
30.     {
    
31.         for (int i=0;i<4000;i++)
    
32.        {
    
33.             System.out.print("i2=" + i);
    
34.         }
    
35.    }
    
36. }
    
37. 
    
38. class TemplateDemo
    
39. {
    
40.      public static void main(String[] args)
    
41.      {
    
42.          //GetTime gt = new GetTime();
    
43.          SubTime sub = new SubTime();
    
44.          sub.getTime();
    
45.      }
    
46. }

复制代码

为什么runcode()复写后调用的是子类的runcode()，虽然说是复写了，但是实际上，并没有覆盖父类中的runcode()方法啊，要是定义一个方法，用super调用runcode()，仍是调用的父类中的runcode()啊。
那么在父类中调用的runcode()前面应该有隐式的this吧，既然调用的是子类的runcode()，那么这里的隐式this是代表的子类；
可是毕老师说过，this是代表本类的引用，那在这里this怎么代表子类这个引用了呢？
简单来说，有这么两个问题不解：
1、为什么在父类中有与子类相同的方法，会直接调用子类，而不调用本类的
2、这里如果有隐式this的话，那么为什么this不代表本类的引用，而是代表子类的引用？对this用法还是有些迷惑。

package cn.itcast.test;

/*
需求：获取一段程序运行时间
原理：获取程序开始的时间和结束的时间并相减，即得程序运行的时间
获取时间：System.currentTimeMillis();
*/

class GetTime
{
      public void getTime()
      {
           long start = System.currentTimeMillis();
           runcode();
           long end = System.currentTimeMillis();
           System.out.println("时间为：" + (end - start));
      }

     public void runcode()
    {
         for (int i=0;i<10;i++)
        {
             System.out.print("i1=" + i);
         }

    }
}

class SubTime extends GetTime
{
     public void runcode()
    {
        for (int i=0;i<10;i++)
       {
            System.out.print("i2=" + i);
        }
   }
}

class Test3
{
     public static void main(String[] args)
     {
         //GetTime gt = new GetTime();
         SubTime sub = new SubTime();
         sub.getTime();
         GetTime get = new GetTime();
         get.getTime();
     }
}

你new的SubTime的对象人家当然调用SubTime的方法啊
我在你的代码上又new了个GetTime的对象,它肯定调用GetTime的方法.

1. SubTime sub = new SubTime();
   
2.          sub.getTime();

复制代码

这个完全是SubTime类。
复写了，就覆盖了。
但是覆盖的是子类的函数，而不是父类的函数。

你没有用到多态的知识啊，多态是 GetTime gt = new SubTime();

郭冰川 发表于 2013-2-5 22:28
package cn.itcast.test;

/*

按你说的，我加上了 GetTime get = new GetTime();和get.getTime()；测试后，结果确实是运行的父类的函数。我突然有些明白了，也就是说谁调用方法，那个隐式this就引用的是谁，而不管this是存在于哪个函数之中。谢谢你啊

你用子类的对象调用子类的方法了，所以结果是这样子。如果父类引用指向子类对象，这是调用子类从父类继承的方法，会运行父类中的runcode方法。