1. package cn.learn.test;
   
2. 
   
3. public class Test {
   
4. 
   
5. 
   
6. public static void main(String[] args) {
   
7. Student s = new Student();
   
8. 
   
9. }
   
10. 
    
11. }
    
12. class Person{
    
13. Person(){
    
14. System.out.println("调用父类的构造方法！");
    
15. }
    
16. }
    
17. class Student extends Person{
    
18. Student(){
    
19. System.out.println("调用子类的构造方法！");
    
20. }
    
21. }
    

复制代码

为什么我的main方法里之创建了学生类，但打印结果为甚打印了
调用父类的构造方法！
调用子类的构造方法!

因为子类实例化的时候一定会调用父类的无参构造方法的。其实在子类的代码里，隐藏了一个super();也就是父类的无参构造方法：

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 Student s = new Student();
   
6. 
   
7.         }
   
8. 
   
9. }
   
10. 
    
11. class Person {
    
12. 
    
13.         Person() {
    
14. 
    
15.                 System.out.println("调用父类的构造方法！");
    
16. 
    
17.         }
    
18. 
    
19. }
    
20. 
    
21. class Student extends Person {
    
22. 
    
23.         Student() {
    
24. 
    
25.                 super();        //这个是隐藏的，调用父类的构造方法
    
26. 
    
27.                 System.out.println("调用子类的构造方法！");
    
28. 
    
29.         }
    
30. 
    
31. }

复制代码

在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行都有一条隐式的super()，super()会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();。

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Student s = new Student();
   
5. 
   
6.         }
   
7. 
   
8. }
   
9. 
   
10. class Person {
    
11.         Person() {
    
12.                 System.out.println("调用父类的构造方法！");
    
13.         }
    
14. }
    
15. 
    
16. class Student extends Person {
    
17.         Student() {
    
18.                 //子类会强制调用父类无参的构造方法，并且这个语句是隐藏的，即
    
19.                 //super();
    
20.                 System.out.println("调用子类的构造方法！");
    
21.         }
    
22. }

复制代码

并且，如果父类中没有无参的构造方法，比如下面这种情况：

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Student s = new Student();
   
5. 
   
6.         }
   
7. 
   
8. }
   
9. 
   
10. class Person {
    
11. //这里因为只定义一个有参数的构造方法，把默认的无参构造方法清除了，导致编译报错。
    
12.         Person(String name) {
    
13.                 System.out.println("调用父类的构造方法！");
    
14.         }
    
15. }
    
16. 
    
17. class Student extends Person {
    
18.         Student() {
    
19.                 //子类会强制调用父类无参的构造方法，并且这个语句是隐藏的，即
    
20.                 //super();
    
21.                 System.out.println("调用子类的构造方法！");
    
22.         }
    
23. }

复制代码

这样的情况下，因为父类没有无参的构造方法，程序是无法编译的。

但是，如果把隐藏的构造方法改成有参数的，则程序可以编译通过，即：

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Student s = new Student();
   
5. 
   
6.         }
   
7. 
   
8. }
   
9. 
   
10. class Person {
    
11.         Person(String name) {
    
12.                 System.out.println("调用父类的构造方法！");
    
13.         }
    
14. }
    
15. 
    
16. class Student extends Person {
    
17.         Student() {
    
18.                 //子类会强制调用父类无参的构造方法，并且这个语句是隐藏的，即
    
19.                 //super();
    
20. //这里，将子类的构造方法中隐藏的super()显式写成super(字符串)，也就是父类的构造方法，程序可以通过编译
    
21.                 super("string");
    
22.                 System.out.println("调用子类的构造方法！");
    
23.         }
    
24. }

复制代码

总结下：
1、子类构造方法默认调用父类的无参构造方法，隐含调用语句super()。
2、父类构造方法如果没有无参的构造方法，子类可以显式的调用父类有参数的构造方法，即super(父类构造方法的参数类型)，也可以通过编译。

package cn.learn.test;



public class Test {





public static void main(String[] args) {

Student s = new Student();



}



}

class Person{

Person(){

System.out.println("调用父类的构造方法！");

}

}

class Student extends Person{

Student(){
     super(); //这里会有个默认的父类的构造函数，不写 super(); 也会有
System.out.println("调用子类的构造方法！");

}

}

这就是类与类之间使用extends关键字产生的继承关系的特性。在子类的构造函数中如果你不写super()，运行时，虚拟机会在子类构造函数自动添加上去一个super()来调用父类构造函数。

希望你看一下毕老师的视频，关于继承这部分的。

因为 子类的构造方法中，你没有写明 要调用父类哪一个构造方法的时候，会有一条 隐式的 super() ，代表调用父类的空参数构造方法。

当然了，你也可以写明调用父类的哪一个构造方法，用参数来区分。你传递什么样的参数，就会调用与之对应的构造方法。