个人总结：
1.子类构造方法中没有显式使用super，Java 也会默认调用父类的无参构造方法
2.当父类中没有无参构造方法，只有有参构造方法时，子类构造方法就必须显式地使用super来调用父类的有参构造方法。
3.如果父类没有定义任何构造方法，编译器会自动为父类生成一个无参构造方法。但如果父类已经定义了有参构造方法，编译器不会自动生成无参构造方法，此时子类必须显式调用父类的有参构造方法。
在 Java 的面向对象编程世界里，继承是一个极为重要的特性，它让代码得以复用和扩展，构建出层次分明的类体系。而super关键字，就像是一把神奇的钥匙，在继承的场景中发挥着不可或缺的作用。它能够帮助我们轻松访问父类的成员，理解和掌握super关键字，对于编写高效、健壮的 Java 代码至关重要。接下来，我们就深入探究一下super关键字的奥秘。
一、super 关键字的基本概念
super是 Java 中的一个关键字，它主要用于在子类中访问父类的成员，包括成员变量、成员方法以及构造方法 。需要明确的是，super代表的是对当前对象父类对象的引用，但它并不像普通对象引用那样可以随意使用，它有着特定的使用场景和规则。
二、super 调用父类构造方法
在类的继承关系中，当创建子类对象时，会先调用父类的构造方法，然后再调用子类自身的构造方法，这是 Java 对象初始化的一个重要机制。而super关键字可以在子类构造方法中显式地调用父类的构造方法。
1. 无参构造方法调用
先来看一个简单的例子，定义一个父类Animal：
class Animal {
public Animal() {
System.out.println("Animal类的无参构造方法被调用");
}
}再定义一个子类Dog继承自Animal：
class Dog extends Animal {
public Dog() {
System.out.println("Dog类的无参构造方法被调用");
}
}在测试类中创建Dog对象：
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
}
}运行结果为：
Animal类的无参构造方法被调用
Dog类的无参构造方法被调用可以看到，在创建Dog对象时，即使子类构造方法中没有显式使用super，Java 也会默认调用父类的无参构造方法。这是 Java 的一个隐式规则，目的是确保父类对象先完成初始化，为子类对象的初始化提供基础。
2. 有参构造方法调用
当父类中没有无参构造方法，只有有参构造方法时，子类构造方法就必须显式地使用super来调用父类的有参构造方法。例如，修改Animal类：
class Animal {
private String name;
public Animal(String name) {
this.name = name;
System.out.println("Animal类的有参构造方法被调用，动物名称：" + name);
}
}然后修改Dog类的构造方法：
class Dog extends Animal {
public Dog(String name) {
super(name);
System.out.println("Dog类的有参构造方法被调用");
}
}测试代码如下：
public class Main {
public static void main(String[] args) {
Dog dog = new Dog("旺财");
}
}运行结果：
Animal类的有参构造方法被调用，动物名称：旺财
Dog类的有参构造方法被调用在子类Dog的构造方法中，super(name)这行代码明确指定了调用父类Animal的有参构造方法，并将参数传递过去，这样才能正确完成对象的初始化过程。同时要注意，super调用父类构造方法的语句必须是子类构造方法的第一行代码 ，否则会编译报错。
三、super 访问父类成员变量
当子类中定义了与父类同名的成员变量时，如果在子类中直接访问该变量名，默认访问的是子类自身的成员变量。此时，如果想要访问父类的同名成员变量，就可以使用super关键字。
定义父类Person：
class Person {
String name = "父类的姓名";
}定义子类Student继承自Person：
class Student extends Person {
String name = "子类的姓名";
public void printNames() {
System.out.println("子类的name：" + name);
System.out.println("父类的name：" + super.name);
}
}测试代码：
public class Main {
public static void main(String[] args) {
Student student = new Student();
student.printNames();
}
}运行结果：
子类的name：子类的姓名
父类的name：父类的姓名通过super.name，我们在子类Student中成功访问到了父类Person的成员变量name，避免了变量访问的混淆。
四、super 调用父类成员方法
同样，当子类重写了父类的方法时，如果在子类中想要调用父类被重写的方法，也可以借助super关键字。
定义父类Vehicle：
class Vehicle {
public void run() {
System.out.println("车辆在行驶");
}
}定义子类Car继承自Vehicle并重写run方法：
class Car extends Vehicle {
@Override
public void run() {
super.run();
System.out.println("汽车在马路上快速行驶");
}
}测试代码：
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.run();
}
}运行结果：
车辆在行驶
汽车在马路上快速行驶在子类Car的run方法中，super.run()调用了父类Vehicle的run方法，这样既保留了父类方法的功能，又在其基础上进行了扩展，实现了代码的复用和增强。
五、父类定义有参、无参构造方法的各种情况
在 Java 中，如果父类没有定义任何构造方法，编译器会自动为父类生成一个无参构造方法。但如果父类已经定义了有参构造方法，编译器不会自动生成无参构造方法，此时子类必须显式调用父类的有参构造方法。
1.关键规则总结：
| 父类情况 | 子类构造方法中是否显式调用super() | 结果 |
|---|---|---|
| 有无参构造方法 | 未显式调用super() | 编译器自动插入super();（调用父类无参构造） |
| 有参构造方法但没有无参构造方法 | 未显式调用super() | ❌ 编译错误：找不到父类的无参构造方法 |
| 有参构造方法但没有无参构造方法 | 显式调用super(参数); | ✅ 正确：调用父类的有参构造方法 |
2.示例代码分析
父类没有定义任何构造方法
class Parent {
// 编译器会自动添加无参构造方法：
// public Parent() {}
}
class Child extends Parent {
public Child() {
// 编译器会自动插入 super();
}
}父类只有有参构造方法
class Parent {
public Parent(int value) { // 定义了有参构造方法
// ...
}
// 注意：编译器不会自动生成无参构造方法！
}
class Child extends Parent {
public Child() {
// ❌ 编译错误：没有super()，但父类没有无参构造方法
}
public Child(int value) {
super(value); // ✅ 必须显式调用父类的有参构造方法
}
}3. 常见错误案例
以下代码会导致编译错误：
class Animal {
private String name;
public Animal(String name) { // 父类只有有参构造
this.name = name;
}
}
class Dog extends Animal {
public Dog() {
// ❌ 编译错误：没有super()，但父类没有无参构造
}
}修正方式：在子类构造方法中显式调用父类的有参构造方法
class Dog extends Animal {
public Dog(String name) {
super(name); // ✅ 显式调用父类的有参构造
}
}六、super( )详解
1.super() 是什么？
在 Java 中，super()是子类构造方法中调用父类构造方法的特殊语法。它必须是子类构造方法的第一行代码。
2.为什么需要 super()？
当创建子类对象时，Java 会先初始化父类的部分。通过super()，我们可以显式指定如何初始化父类的状态。
3.最简单的示例
下面是一个基础示例，展示super()的基本用法：
// 父类：动物
class Animal {
private String name;
// 父类的构造方法
public Animal(String name) {
this.name = name;
System.out.println("创建了一只动物：" + name);
}
public String getName() {
return name;
}
}
// 子类：狗
class Dog extends Animal {
private String breed;
// 子类的构造方法
public Dog(String name, String breed) {
super(name); // 调用父类的构造方法，必须在第一行
this.breed = breed;
System.out.println("这是一只" + breed + "：" + name);
}
public String getBreed() {
return breed;
}
}
// 测试类
public class Main {
public static void main(String[] args) {
Dog dog = new Dog("旺财", "金毛");
System.out.println(dog.getName() + "是一只" + dog.getBreed());
}
} 
4.关键代码解释
父类构造方法：
public Animal(String name) {
this.name = name;
}Animal类的构造方法接收一个name参数，用于初始化动物的名称。
子类构造方法中的super()：
public Dog(String name, String breed) {
super(name); // 调用父类构造方法，初始化name
this.breed = breed; // 初始化子类特有的属性
}super(name)将name参数传递给父类的构造方法，确保父类的name字段被正确初始化。
如果省略super(name)，Java 会默认调用父类的无参构造方法（如果存在）。
5.执行流程
当执行Dog dog = new Dog("旺财", "金毛");时：
- 调用子类构造方法：
Dog(String name, String breed)- 隐式 / 显式调用父类构造方法：
- 通过
super(name)调用Animal(String name)- 父类初始化完成：
Animal的name字段被设置为 "旺财"- 继续执行子类构造方法：
this.breed = breed将breed设置为 "金毛"
