有这样三个类，Person,Student.GoodStudent。其中Student继承了Person,GoodStudent继承了Student,三个类中只有默认的构造函数，用什么样的方法证明在创建Student类的对象的时候是否调用了Person的构造函数，在创建GoodStudent类的对象的时候是否调用了Student构造函数？如果在创建Student对象的时候没有调用Person的构造函数，那么采用什么样的手段可以调用父类的构造函数？

在加载子类的时候java底层会自动加载父类的无参构造函数，只要在无参构造函数里面打印就好了，

1. public class Test
   
2. {
   
3.      public static void main(String []args)
   
4.      {
   
5.              GoodStudent GS = new GoodStudent();
   
6.      }
   
7. }   
   
8. 
   
9. class Student extends Person
   
10. {
    
11.         Student(){
    
12.                 System.out.println("Student");
    
13.                 }
    
14. }
    
15. class  Person
    
16. {
    
17.         Person(){
    
18.                 System.out.println("Person");
    
19.                 }
    
20. }
    
21. class GoodStudent extends Student
    
22. {
    
23.         GoodStudent(){
    
24.                 System.out.println("GoodStudent");
    
25.                 }
    
26. }

复制代码

这是类的加载问题，自己动手试一下就知道了

证明有没有调用，直接在构造函数里整个输出语句就行，如果没有调用，使用super.Student()和super.Person(),super就是父类的意思

默认的构造函数就是无参的构造函数，例子

1. public class Test2 {
   
2.         public static void main(String[] args) {
   
3.                 new Student();
   
4.                 System.out.println("**********************");//分隔条
   
5.                 new GoodStudent();
   
6.         }
   
7. }
   
8. 
   
9. 
   
10. class Person{
    
11.         Person(){
    
12.                 System.out.println("person的构造函数");
    
13.         }
    
14. }
    
15. 
    
16. 
    
17. class Student extends Person{
    
18.         Student(){
    
19.                 System.out.println("Student的构造函数");
    
20.         }
    
21. }
    
22. 
    
23. class GoodStudent extends Student{
    
24.         GoodStudent(){
    
25.                 System.out.println("GoodStudent的构造函数");
    
26.         }
    

复制代码

结果

1. person的构造函数
   
2. Student的构造函数
   
3. **********************
   
4. person的构造函数
   
5. Student的构造函数
   
6. GoodStudent的构造函数

复制代码

就是说当你new Student();它会调用父类Person的构造函数；new GoogStudent()时，它会调用Student父类构造函数,当调用student构造函数时会调用person的构造函数，也就是说GoogStudent会调用它所用父类的构造函数;不存在不会调用父类构造函数的情况

class Person
{
        protected Person()
        {
                System.out.println("我是Person类，这是我的无参构造器");
        }
        
}
class Student extends Person
{
        protected Student() {
                System.out.println("我是Student类，这是我的无参构造器");
        }

}
class GoodStudents extends Student
{
        protected GoodStudents()
        {
                System.out.println("我是GoodStudents类，这是我的无参构造器");
        }

}
public class Test_Stu {
        public static void function(Object obj)
        {
                if(obj instanceof Student )
                {
                        Student sc1=new Student();
                        
                }
                else if(obj instanceof GoodStudents )
                {
                        GoodStudents sc2=new GoodStudents();
                        
                }
                else if(obj instanceof Person )
                {
                        Person sc3=new Person();
                        
                }
        }
        
        public static void main(String[] args) {
                       
                function(new Student());//调用Person构造器和Student构造器
                //function(new GoodStudents());//调用Student构造器和GoodStudents构造器
        }
}
输出结果：
我是Person类，这是我的无参构造器
我是Student类，这是我的无参构造器
我是Person类，这是我的无参构造器
我是Student类，这是我的无参构造器

1. class Person{
   
2.         public Person(){
   
3.          System.out.println("Person");
   
4.         }
   
5.        }
   
6.        class Student extends Person{
   
7.         public Student(){
   
8.          System.out.println("Student");
   
9.         }
   
10.        }
    
11. class GoodStudent extends Student{
    
12.         public GoodStudent(){
    
13.          System.out.println("GoodStudent");
    
14.         }
    
15.        }
    
16.        public class Test6{
    
17.         public static void main(String args[]){
    
18.         Student s = new Student();
    
19.         System.out.println("===================");
    
20.          GoodStudent gs=new GoodStudent();
    
21.         }
    
22. }

复制代码

运行结果：
Person
Student
===================
Person
Student
GoodStudent


这也就说明继承以后都是默认调用的