当前位置：日志文章 > 详细内容

Java 中的 super 关键字用法指南

2025年07月17日 • Java •

个人总结：1.子类构造方法中没有显式使用super，java 也会默认调用父类的无参构造方法2.当父类中没有无参构造方法，只有有参构造方法时，子类构造方法就必须显式地使用super来调用父类的有参构造

个人总结：

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