访问不可覆盖的超类方法时使用“ super”关键字

Question

我试图摆脱Java继承的束缚，并且了解到，当重写子类中的方法（和隐藏字段）时，仍然可以使用“ super”关键字从父类中访问它们。

我想知道的是，是否应将“ 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（以在代码中显示您正在访问超类），还是仅在覆盖/隐藏的超实例中使用它们（以便它们脱颖而出）。

Answer 1

不要使用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
    }

}