Java 中的 super 关键字

最新推荐文章于 2025-07-09 21:55:38 发布

原创最新推荐文章于 2025-07-09 21:55:38 发布 · 1k 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java基础补充专栏收录该内容

6 篇文章

订阅专栏

个人总结：

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设置为 "金毛"