java - Java中的运行时多态性没有 "abstract"？

Question

我正在阅读官方的 Oracle 教程，其中通过 3 个类的类层次结构示例介绍了多态性的概念； Bicycle 是父类(super class)，MountainBike 和 RoadBike 是 2 个子类。

它展示了两个子类如何通过声明不同版本来重写 Bicycle 中声明的方法“printDescription”。

最后，在接近尾声时，教程提到 Java 虚拟机 (JVM) 为每个变量中引用的对象调用适当的方法。

但是，关于多态性的教程没有提到“抽象”类和方法的概念。除非 Bicycle 中的 printDescription() 声明为“抽象”，否则如何实现运行时多态性？我的意思是，在这个例子中，编译器基于什么提示决定不在编译时将方法调用绑定(bind)到引用类型，并认为应该将其留给 JVM 在运行时处理？

下面是使用的示例:

public class Bicycle {
    public int cadence;
    public int gear;
    public int speed;

    public Bicycle(int startCadence, int startSpeed, int startGear) {
      gear = startGear;
      cadence = startCadence;
      speed = startSpeed;
    }

    public void setCadence(int newValue) {
      cadence = newValue;
    }

    public void setGear(int newValue) {
      gear = newValue;
    }

    public void applyBrake(int decrement) {
      speed -= decrement;
    }

    public void speedUp(int increment) {
      speed += increment;
    }

    public void printDescription(){
        System.out.println("\nBike is " + "in gear " + this.gear
         + " with a cadence of " + this.cadence +
         " and travelling at a speed of " + this.speed + ". ");
    }

}

public class MountainBike extends Bicycle {
  private String suspension;

  public MountainBike(
           int startCadence,
           int startSpeed,
           int startGear,
           String suspensionType){
    super(startCadence,
          startSpeed,
          startGear);
    this.setSuspension(suspensionType);
  }

  public String getSuspension(){
    return this.suspension;
  }

  public void setSuspension(String suspensionType) {
    this.suspension = suspensionType;
  }

  public void printDescription() {
    super.printDescription();
    System.out.println("The " + "MountainBike has a" +
        getSuspension() + " suspension.");
  }

}

public class RoadBike extends Bicycle{

  private int tireWidth;

  public RoadBike(int startCadence,
                int startSpeed,
                int startGear,
                int newTireWidth){
    super(startCadence,
          startSpeed,
          startGear);
    this.setTireWidth(newTireWidth);
  }

  public int getTireWidth(){
    return this.tireWidth;
  }

  public void setTireWidth(int newTireWidth){
    this.tireWidth = newTireWidth;
  }

  public void printDescription(){
    super.printDescription();
    System.out.println("The RoadBike"
        " has " + getTireWidth() +
        " MM tires.");
  }
}


public class TestBikes {
    public static void main(String[] args){
        Bicycle bike01, bike02, bike03;

      bike01 = new Bicycle(20, 10, 1);
      bike02 = new MountainBike(20, 10, 5, "Dual");
      bike03 = new RoadBike(40, 20, 8, 23);

      bike01.printDescription();
      bike02.printDescription();
      bike03.printDescription();
      }
}

Answer 1

How is run-time polymorphism achieved unless printDescription() in Bicycle is declared "abstract"?

为什么你认为抽象类会改变任何事情？抽象类主要做两件事

1. 允许程序员声明一个本身无法实例化的类，强制子类化，并且
2. 允许程序员通过声明方法抽象来强制子类提供方法的实现。

请注意，第 2 点并不意味着多态性不起作用，除非在基类上将方法声明为抽象方法；相反，它为开发人员提供了强制子类提供实现的机会，这在不涉及任何抽象用法的子类化场景中不需要。

就是这样。换句话说，抽象的概念补充了 Java 的多态性——它是一种语言特性，但与 Java 在运行时调用方法的动态分派(dispatch)没有任何关系。每当在实例上调用方法时，都会使用运行时实例的类型来确定要使用哪个方法实现。