我正在尝试掌握 Java 中的继承窍门，并且了解到当覆盖子类中的方法(和隐藏字段)时，仍然可以使用“super”关键字从父类(super class)访问它们。

我想知道的是，“super”关键字是否应该用于非覆盖方法？

有什么区别(对于非覆盖方法/非隐藏字段)吗？

我在下面整理了一个示例。

public class Vehicle {
    private int tyreCost;

    public Vehicle(int tyreCost) {
         this.tyreCost = tyreCost;
    }

    public int getTyreCost() {
        return tyreCost;
    }        
}

和

public class Car extends Vehicle {
    private int wheelCount;

    public Vehicle(int tyreCost, int wheelCount) {
        super(tyreCost);
        this.wheelCount = wheelCount;
    }   

    public int getTotalTyreReplacementCost() {
        return getTyreCost() * wheelCount;
    }   
}

具体来说，假设 getTyreCost() 没有被覆盖，getTotalTyreReplacementCost() 应该使用 getTyreCost() 还是 super.getTyreCost() ?

我想知道是否应该在访问父类(super class)的字段或方法的所有实例中使用 super(以在代码中显示您正在访问父类(super class))，或者仅在被覆盖/隐藏的实例中使用(因此它们站立出去)。

最佳答案

不要使用 super 关键字来引用其他未被覆盖的方法。这会让其他试图扩展您的类的开发人员感到困惑。

让我们看一些确实以这种方式使用super 关键字的代码。这里我们有 2 个类:Dog 和 CleverDog:

/* file Dog.java */
public static class Dog extends Animal {

    private String name;

    public Dog(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

/* file CleverDog.java */
public class CleverDog extends Dog {

    public CleverDog(String name) {
         super(name);
    }

    public void rollover() {
        System.out.println(super.getName()+" rolls over!");
    }

    public void speak() {
        System.out.println(super.getName() + " speaks!");
    }

}

现在，假设您是该项目的一名新开发人员，您需要为电视上的一只聪明的狗做一些特定的行为:那只狗必须使出所有的把戏，但应该使用它虚构的电视名称。为此，您需要覆盖 getName(...) 方法...

/* file DogOnTv.java */
public class DogOnTv extends CleverDog {

    String fictionalName;

    public DogOnTv(String realName, String fictionalName) {
        super(realName);
        fictionalName = fictionalName;
    }

    public String getName() {
        return fictionalName;
    }

}

... 并落入原始开发者设置的陷阱，他们异常使用 super 关键字!

上面的代码是行不通的——因为在最初的 CleverDog 实现中，getName() 是使用 super 关键字调用的.这意味着它总是调用 Dog.getName() - 与任何覆盖无关。因此，当您使用新的 DogOnTv 类型时...

    System.out.println("Showcasing the Clever Dog!");
    CleverDog showDog = new CleverDog("TugBoat");
    showDog.rollover();
    showDog.speak();

    System.out.println("And now the Dog on TV!");
    DogOnTv dogOnTv = new DogOnTv("Pal", "Lassie");
    dogOnTv.rollover();

...你得到错误的输出:

Showcasing the Clever Dog!
Tugboat rolls over!
Tugboat speaks!

And now the Dog on TV!
Pal rolls over!
Pal speaks!

当您覆盖方法时，这不是通常预期的行为，因此您应该避免在不属于它的地方使用 super 关键字来造成这种混淆。

但是，如果这实际上是您想要的行为，请改用 final 关键字 - 以清楚地表明该方法不能被覆盖:

/* file CleverDog.java */
public class CleverDog extends Dog {

    public CleverDog(String name) {
         super(name);
    }

    public final String getName() { // final so it can't be overridden
        return super.getName();
    }

    public void rollover() {
        System.out.println(this.getName()+" rolls over!"); // no `super` keyword
    }

    public void speak() {
        System.out.println(this.getName() + " speaks!"); // no `super` keyword
    }

}

关于java - 访问未覆盖的父类(super class)方法时使用 'super' 关键字，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12803346/