super關(guān)鍵字在Java中用于引用當前對象的父類，主要用途包括訪問父類方法、調(diào)用父類構(gòu)造器以及解決字段名沖突。1. 訪問父類方法：當子類重寫父類方法時，可通過super.method()調(diào)用父類版本以擴展其行為而非完全替換；2. 調(diào)用父類構(gòu)造器：子類構(gòu)造器中使用super()或super(args)初始化父類字段，且該語句必須位于子類構(gòu)造器的第一行；3. 解決字段名沖突：若子類與父類定義同名字段，可用super.fieldName明確訪問父類字段。

The super keyword in Java is used to refer to the parent class (or superclass) of the current object. It's super handy when you're working with inheritance, especially if you want to access methods or constructors from the parent class that might be hidden or overridden in the subclass.

Let’s break it down into common use cases so you can see how and why you'd use super.

Accessing Parent Class Methods

When a subclass overrides a method from its parent class, the version in the child class takes precedence. But sometimes you still want to run the parent’s version — maybe to extend its behavior instead of completely replacing it.

For example:

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        super.speak();  // calls the Animal version first
        System.out.println("Dog barks");
    }
}

In this case:

• super.speak() runs the original method from Animal
• Then we add extra behavior specific to Dog

This pattern is really useful when you want to build on existing logic without duplicating code.

Calling the Parent Class Constructor

If your subclass has a constructor, you often need to initialize fields that belong to the parent class. You can do that by calling the parent’s constructor using super() as the first line in your subclass constructor.

Here’s what that looks like:

class Vehicle {
    Vehicle(String brand) {
        System.out.println("Vehicle brand: "   brand);
    }
}

class Car extends Vehicle {
    Car(String brand) {
        super(brand);  // must come first
        System.out.println("Car created");
    }
}

A few things to note:

• super() must be the first statement in the constructor
• If you don’t explicitly call super(), Java adds a no-arg super() for you automatically
• If the parent doesn't have a no-arg constructor, you must provide the correct arguments

Resolving Field Name Conflicts

Sometimes a subclass defines a field with the same name as one in the parent class. In that case, you can use super.fieldName to access the parent’s version.

Example:

class Parent {
    int value = 10;
}

class Child extends Parent {
    int value = 20;

    void printValues() {
        System.out.println("Child value: "   value);
        System.out.println("Parent value: "   super.value);
    }
}

This helps avoid confusion when both classes define similar fields and you need to distinguish between them.

So yeah, super isn’t magic — it’s just a way to clearly say “I want to use something from my parent class.” Whether it’s a method, constructor, or field, super gives you control over which version you’re referring to.

And honestly, once you get used to it, it makes working with inheritance a lot cleaner and more flexible.

That’s basically it. Not too complicated, but definitely important when you start building more complex class hierarchies.

以上是Java中的超級關(guān)鍵字是什么？的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！