class Father
                {
                       
                        Father(){}
                       
                        Fahter(int age)
                        {
                                System.out.println("father age:"+age);
                        }
                }

                class Son extends Father
                {
                        Son()
                        {
                                //默认这里有一个东西 super();
                                //this(20);
                                System.out.println("son");
                        }

                        Son(int age)
                        {
                                super(age);
                                System.out.println("son age:"+age);
                        }
                }

                Son s = new Son();  //father;son

                Son s = new Son(20);//father;son age:20

调用对象函数方法时，运行的步骤得到对应的结果的思路不是很明白？？求讲解一下思路

楼主你好   你这段代码是子类Son继承了父类 Father
当父类有构造函数的时候，子类就可以实例化，也就是new对象了

您定义的都是构造方法，构造方法就是当对象创建的时候才会被调用，从而加载到内存。
实例化=new对象=对象的创建，对象的创建是堆内存中。

子类创建对象时，默认子类所有的构造函数的首行都隐藏了一句super()，通过先参考父类的构造函数对对象的属性的定义，然后再执行子类的构造函数，完成对象的构造函数初始化。
如果子类想要指定父类的非默认构造函数，需要再构造函数首行加上对应的super语句来执行指定的父类构造函数。

你上边的程序解释如下：
     你创建了Father类，
      Father(){}为默认构造方法，
      Fahter(int age)   //为带参数的构造方法
                        {
                                System.out.println("father age:"+age);


                        }
                }
Son类继承了Father类，是Father类的子类
        Son() //为Son类的默认构造方法
                        {
                                //默认这里有一个东西 super();
                                //this(20);
                                System.out.println("son");
                        }

      Son(int age)//为Son类指定参数的构造方法
                        {
                                super(age);
                                System.out.println("son age:"+age);
                        }

    Son s = new Son();这句是利用Son()这个默认构造方法初始化并创建Son类对象s.
     Son s = new Son(20);这句是利用Son（int age）{}这个带参数构造方法初始化并创建Son类对象s。
   super()是执行父类的够造方法；

记得及时处理帖子哦~  追问，或改成【已解决】~

1. class Father
   
2. {
   
3.        Father(){}
   
4. 
   
5.         Fahter(int age)
   
6.         {
   
7.               System.out.println("father age:"+age);
   
8.        }
   
9. }
   
10. 
    
11. class Son extends Father
    
12. {
    
13.             Son()
    
14.             {
    
15.                     System.out.println("son");
    
16.             }
    
17. 
    
18.             Son(int age)
    
19.            {
    
20.                      super(age);
    
21.                      System.out.println("son age:"+age);
    
22.             }
    
23. }
    

复制代码

首先要明确的是：
1.相应的类建立相应的对象
2.相应的构造函数只用来初始化相应的对象
执行过程如下：
Son s = new Son();  这个语句建立的是Son对象并且是无参数的，它只跟Son（）这个构造函数有关，与父类没有任何关系，结果是son
Son s = new Son(20);这个语句建立的也是Son对象但是有参数20，它只跟Son(int age)这个构造函数有关，与父类无关，结果son age:20

首先，理解继承和构造方法的概念及用法，他们都有什么特征。而不是一味看结果。

class Father
        {
                
                Father(){}
                
                Father(int age)
                {
                        System.out.println("father age:"+age);
                }
        }
       
class Son extends Father
{
        Son()
        {
                //默认这里有一个东西 super();
                //this(20);
                System.out.println("son");
        }

        Son(int age)
        {
                super(age);
                System.out.println("son age:"+age);
        }
}
public class Test1 {
        public static void main(String[] args) {
                Son s = new Son();  //father;son

                                Son s1 = new Son(20);//father;son age:20
        }
       

}
一、子类在构造的过程中必须调用父类的构造方法，若没有显示地调用，则系统默认调用父类的空构造方法；子类的构造方法也可以在用this关键字调用其他的构造方法，而其他的构造方法中必须调用了父类的构造方法。
二：对父类构造方法的引用，或对本类中其他构造方法的引用必须放在第一条语句，因为只有先构造出父类对象才能有子类像（调用父类构造方法的过程，实际上是在子类对象中构造了一个父类的对象）
三：执行过程如下：
a)Son s = new son(); 在创建对象s的过程中，先调用了 Son类中的Son()这个构造方法，该构造方法由于没有显示调用父类构造方法，所以就默认地首先调用父类中的Father()这个构造方法，实际上是在对象s中创建了一个父类对象，然后继续执行Son()方法中的打印语句，输出：son
b)Son s1 = new Son(20);  在创建s1的过程中，先调用了Son类中的Son(int age)这个构造方法，该方法中的super(age)语句时显示地调用了父类中的Father(int age)方法，该方法在对象s1的内存空间先建立了一个父类对象（若定义了成员变量，还会对成员变量进行默认初始化），并执行System.out.println("father age:"+age);打印出：father age:20
然后父类方法结束回到Son（int age）方法中继续执行System.out.println("son age:"+age);输出：son age:20
所以最后结果为:
son
father age:20
son age:20

邵彩华 发表于 2013-4-1 17:32
class Father
        {
                

嗯 谢谢你们的解答

Son s = new Son();创建这个对象时，调用父类的 Father(){}方法，然后再执行子类的Son()方法；当Son s = new Son(20)方法构建时，遇到 super(age)调用父类的有参函数  Fahter(int age)，因为传入的参数是20，所以父类和子类的年纪都是20.