有如下父类和子类：

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

复制代码

打印结果竟然是
，有点疑惑：为什么在父类构造函数中调用了this.i++，就会影响到子类呢？子类并没有让i自增呀？

初始化Son时，父类的构造方法先执行，i已经自增了
子类继承了父类的成员i,父类的i自增了，子类当然也随之变化了。

子类构造函数前,会先调用父类构造函数,所以你调用了i++,让他自增了

    因为你子类默认调用了父类的空参数构造函数

你子类继承了父类了，子类就会默认实现父类的方法。你可以在子类中重写下方法，或者写个子类特有的。

子类 默认继承了父类的构造方法 ，new Son();运行，this.i++运行

这是我昨天看视频的笔记
一、子父类中构造函数的特点-子类实例化过程
        1、构造函数是不可以覆盖的，因为构造函数和类函数一致，所以不可以
        2、在子类的构造函数的第一行，会有默认有一条 隐式 构造函数  super();
        3、在对子类对象进行初始化时，父类的构造函数也会运行。
        4、那是因为子类的构造函数默认第一行，有一条隐式的语句 super();
        5、super() 会访问父类中空参数的构造函数，而且子类中所有的构造函默认的第一行都是 super()
        6、子类一定要访问父类中的构造函数
                (1)、因为父类中的数据，子类可以直接获取，所以子类在建立式，需要先查看父类是如何对这些数据进行初始化的
                (2)、所以子类在对像初始化时，要先访问一下父类中的构造函数
                (3)、如果要访问父类中指定的构造函数，可以通过手动定义 super 语句的方式来指定
                (4)、自己定义的 super 也得放到构造函数的第一行
                (5)、要注意参数列表
        7、结论                子类的实例化过程
                (1)、子类的所有构造函数，默认都会访问父类中的空参数的构造函数
                (2)、因为子类每一个构造函数内的第一行都有一句 隐式super()
                (3)、当父类中没有空参数的构造函数时，子类必须手动通过 super 语句形式来指定要访问父类中的构造函数
                (4)、当然，子类的构造函数第一行也可以手动指定this语句，来访问本类中的构造函数，子类中至少会有一个构造函数，会访问父类中的构造函数
                (5)、这就是子类的实例化过程
                (6)、当然，最顶的父类也有 super();  它 extends Object
        8、this 和 super 都必须要写在第一行，因为初始化动作要先做，
        9、所以 this() 和 super() 不能同时存在于同一构造函数内

1. class Tel{
   
2.         public int num;
   
3.         Tel(int num){
   
4.                 this.num = num;
   
5.         }
   
6. }
   
7. class NewTel extends Tel{
   
8.         NewTel(int num){
   
9.                 super(num);  //隐式构造函数，默认第一行
   
10.                
    
11.         }
    
12. }
    
13. public class Demo{
    
14.         public static void main(String[] args){
    
15.                 NewTel n = new NewTel(4);
    
16.                 System.out.println("num="+n.num);
    
17.         }
    
18. }

复制代码

执行语句：
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:02
执行语句：
new Son();
在调用Son()的构造函数前，会先自动调用父类的无参构造函数：super（），所以先执行 ...

你终于说到点子上了。因为在父类中调用this.i++，在子类new的时候会先隐式调用调用父类无参构造器。这时this.i++就被执行了。实际this仍然指向子类对象。是子类的i++了，而不是他们说的父类的i++后被子类给继承过来的。

舒远 发表于 2011-12-20 10:09
你终于说到点子上了。因为在父类中调用this.i++，在子类new的时候会先隐式调用调用父类无参构造器。这时t ...

:'(，我也说到点上了