代码如下，结果如下，我的问题是，子类中构造函数中，隐式 super();调用了父类的构造函数，父类中有个 speak()的函数，虽然子类把父类该函数给重写了，但是super调用的是父类的构造函数，不是应该调用父类的 speak() 吗？本人新手，基础较弱，请指教
public class Son extends Parent
{
        public static void main(String[] args)
        {
                new Son();
        }
        public void speak()
        {
                System.out.println("子类的i变量:"+this.i);
        }
}        
class Parent
{
        int i = 0;
        Parent()
        {
                this.i++;
                speak();
        }
       
        public void speak()
        {
                System.out.println("父类的i变量:"+this.i);
        }



}

该贴已经同步到 张帅的微博

其实是调用的父类的speak方法,但是因为子类中也有speak方法,所以覆写了.最终运行的则是子类对象的speak方法.

应国炎 发表于 2011-12-20 10:12
其实是调用的父类的speak方法,但是因为子类中也有speak方法,所以覆写了.最终运行的则是子类对象的speak方法 ...

但是，按我的理解，speak() 函数是写在，父类的构造函数中的，并且是在父类构造函数运行的时候运行，那时候跟子类没关系啊

执行语句：
new Son();
在调用Son()的构造函数前，会先自动调用父类的无参构造函数：super（），所以先执行以下语句：
this.i++; //1.最后i=1
speek(); //这边的speek()到底是调用父类还是子类？
注意：super不是一个对象的引用，只是一个指示编译器调用超类方法的关键字！不同于this的。所以在上面中，调用父类的无参构造函数：super（）时，这边使用了super关键字，但实际上this仍然是子类对象的引用。

验证如下：

1. class Son extends Parent
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 new Son();
   
6.         }
   
7.         public void speek()
   
8.         {
   
9.                                       
   
10.                 System.out.println("子类的i变量:"+this.i);
    
11.         }
    
12.         
    
13. }        
    
14. 
    
15. class Parent
    
16. {
    
17.         int i = 0;
    
18.         Parent()
    
19.         {
    
20.                 this.i++;
    
21.                 System.out.println("实际引用类型:"+this);
    
22.                 speek();
    
23.         }
    
24.         
    
25.         public void speek()
    
26.         {                                      
    
27.                 System.out.println("父类的i变量:"+this.i);
    
28.         }
    
29. }

复制代码

测试结果：

1. 实际引用类型:Son@18a992f
   
2. 子类的i变量:1

复制代码

【刚回答过，就直接复制过来了】

monghuan 发表于 2011-12-20 10:21
执行语句：
new Son();
在调用Son()的构造函数前，会先自动调用父类的无参构造函数：super（），所以先执行 ...

这句话不太理解

super不是一个对象的引用，只是一个指示编译器调用超类方法的关键字！不同于this的。所以在上面中，调用父类的无参构造函数：super（）时，这边使用了super关键字，但实际上this仍然是子类对象的引用。

张帅 发表于 2011-12-20 10:15
但是，按我的理解，speak() 函数是写在，父类的构造函数中的，并且是在父类构造函数运行的时候运行，那时 ...

new son();就是创建匿名子类对象,怎么会和子类没关系呢

张帅 发表于 2011-12-20 10:27
这句话不太理解

恩，现在已经明确：问题在“super”关键字身上，
【Java核心技术卷一中文第八版，145页（应该是这页），注释（原话）】
有些人认为super与this引用是类似的概念，实际上，这样比较并不恰当。这是因为super不是一个对象的引用，不能将super赋给另一个对象变量，它只是一个指示编译器调用超类方法的特有关键字。
[我是这么理解的，呵呵，]

继承了父类的方法,你调用的话是先找子类的,如果子类没有才会去父类的找

孤独的人 发表于 2011-12-20 10:47
继承了父类的方法,你调用的话是先找子类的,如果子类没有才会去父类的找

但是构造方法是不可以继承的， 该 speak() 函数在 父类的 构造函数中，子类根本不知道有这个 函数，他怎么会从自己 子类中寻找呢？

我们可以这样理解 ： 当你new一个子类对象时，它会调用父类的构造方法，我们可人认为调用的对象是子类在调用（Son.speak()），如果你没重写这个方法，它就直接去调用父类的方法。

张帅 发表于 2011-12-20 10:56
但是构造方法是不可以继承的， 该 speak() 函数在 父类的 构造函数中，子类根本不知道有这个 函数，他怎 ...

你已经有了void关键字不是构造函数

还是不理解，请大家帮帮我，谢谢了{:soso_e181:}

你要明确一点，创建子类的过程是new Son(),java在创建对象之前会先找Son类的父类就是Parent类，调用子类构造器的时候会先调用父类的同参数列表的构造器。这是隐式调用实际上和super()作用一样。super()调用是显示调用。在调用父类构造函数的时候执行了speek方法。因为子类重写了speek方法。在父类构造器中调用被子类重写的方法时，此时如果是创建子类的对象，程序上下文环境中的this指向的就是正在创建的子类对象。那么调用的就是子类的speek方法。
不知道这样讲你能否明白？

代码的分析如下：

1. class Son extends Parent
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 new Son();
   
6.         }
   
7.         public void speek()
   
8.         {
   
9.                                       
   
10.                 System.out.println("子类的i变量:"+this.i);
    
11.         }
    
12. 
    
13.                 Son()
    
14.                 {
    
15.                         super();//子类实例化过程中会先用父类无参构造函数，Son类从Parent类继承的i会执行+1，再根据就近原则，调用自己重写的speek方法
    
16.                         super.speek();//因为子类重写父类的speek方法，要使用父类的speek方法，要通过关键字super
    
17.                 }
    
18.         
    
19. }        
    
20. 
    
21. class Parent
    
22. {
    
23.         int i = 0;
    
24.         Parent()
    
25.         {
    
26.                 this.i++;
    
27.                 speek();
    
28.         }
    
29.         
    
30.         public void speek()
    
31.         {                                      
    
32.                 System.out.println("父类的i变量:"+this.i);
    
33.         }
    
34. }

复制代码

输出结果：

子类的i变量:1
父类的i变量:1

舒远 发表于 2011-12-20 12:22
你要明确一点，创建子类的过程是new Son(),java在创建对象之前会先找Son类的父类就是Parent类，调用子类构 ...

对，我的疑问就在这里，在父类的构造函数里，给变量 i 赋值，应该是给父类的 变量 i 赋值吧？

张帅 发表于 2011-12-20 13:16
对，我的疑问就在这里，在父类的构造函数里，给变量 i 赋值，应该是给父类的 变量 i 赋值吧？ ...

如果没有子类继承该父类，那就不存在new子类实例这么一说。那你可以认为是在父类中对成员变量i赋值。但是如果有子类，并且调用子类构造函数了，由于java对象创建时初始化具有需要先调用父类构造器的这个特点。程序在运行时的this指向就是子类了。和编译时的指向不是一回事。所以在这个例子中给变量i赋值实际上是在给子类中从父类继承来的那个i赋值。如果你调用的是new Parent(),那么代码中的i赋值语句就肯定是给父类中的赋值。因为就是他自己在调用自己的构造器嘛。
所以说到底的话：要弄明白编译时的this指向和运行时的this指向到底是怎么回事！
通常不会在父类构造函数中调用会被子类重写的方法。有可能引发错误，有时候这个错误是很危险的。

舒远 发表于 2011-12-20 13:23
如果没有子类继承该父类，那就不存在new子类实例这么一说。那你可以认为是在父类中对成员变量i赋值。但是 ...

原来如此，我终于明白了，原来是这样的，看来我看视频的时候没看懂，非常感谢 舒远 ，帮助教会我东西，再次感谢