Java 中的多态非卷曲方法调用(adhoc polymorphism)

Question

让我从一个例子开始。

假设我有一个抽象Vehicle课。

public abstract class Vehicle {
    public Vehicle() {}
    public abstract void ride();
}

类Car和继承自此抽象类的Bicycle。

public class Car extends Vehicle {
    public Car() {}
    @Override
    public void ride() {
        System.out.println("Riding the car.");
    }
}
public class Bicycle extends Vehicle {
    public Bicycle() {}
    @Override
    public void ride() {
        System.out.println("Riding the bicycle.");
    }
}

当我将 ride() 方法应用于实际类型只能在运行时确定的 Vehicle 类型的对象时，JVM 将应用正确版本的 ride() 。

也就是说，在v.ride()排序的柯里方法调用中，多态性以预期的方式工作。

但是，如果我有一个仅接受Vehicle子类型作为参数的方法形式的外部实现呢？那么，如果我有repair(Bicycle b)和repair(Car c)的方法怎么办？未卷曲的多态方法调用repair(v)不起作用。

例：

import java.util.ArrayList;
import java.util.List;
public class Main {
private static void playWithVehicle() {
    List<Vehicle> garage = new ArrayList<Vehicle>();
    garage.add(new Car());
    garage.add(new Car());
    garage.add(new Bicycle());
    garage.forEach((v) -> v.ride()); // Works.
    garage.forEach((v) -> {
        /* This would be nice to have.
        repair(v.castToRuntimeType());
        */
        // This is an ugly solution, but the obvious way I can think of.
        switch (v.getClass().getName()) {
        case "Bicycle":
            repair((Bicycle) v);
            break;
        case "Car":
            repair((Car) v);
            break;
        default:
            break;
        }
    });
}
private static void repair(Bicycle b) {
    System.out.println("Repairing the bicycle.");
}
private static void repair(Car c) {
    System.out.println("Repairing the car.");
}
public static void main(String[] args) {
    playWithVehicle();
}
}

我必须检查类名和向下投射。有没有更好的解决方案？

---

编辑：我的实际目的是我正在遍历一个抽象语法树，我碰巧注意到我想要双重调度。

Ast是一个抽象类，实际的AST节点(如Assign、MethodCall或ReturnStmt(从中继承。 body是Ast的多态列表。

代码片段：

List<Ast> body;
body.parallelStream().forEach((ast) -> {
    // This one won't work.
    visit(ast);
    // This one will work.
    if (ast instanceof Assign) {
        visit((Assign) ast);
    } else if (ast instance of MethodCall) {
        visit((MethodCall) ast);
    } else if (ast instance of ReturnStmt) {
        visit((ReturnStmt) ast);
    }
    // etc. for other AST nodes
});
private void visit(Assign ast) {
}
private void visit(MethodCall ast) {
}
private void visit(ReturnStmt ast) {
}

我实现双重调度的唯一可能性是检查类并向下投递或正确实现访问者模式，对吧？

Answer 1

答：Java 中没有多重调度，可以通过instanceof或访问者模式来模拟。

看这里：Java 方法重载 + 双重调度

另请参阅此处：https://en.wikipedia.org/wiki/Multiple_dispatch#Examples_of_emulating_multiple_dispatch

附带说明一下，这在 C# 中可以通过dynamic调用来实现：如何使用扩展构建双重调度

这在编译为JVM字节码的许多语言中也是可能的，例如提到了Groovy。