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()的curried方法调用中，多态性以预期的方式工作。

但是如果我有一个只接受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是一个抽象类，从Assign，MethodCall或ReturnStmt这样的实际AST节点继承。 body是Ast s。

的多态列表

代码段：

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 method overloading + double dispatch

另见：https://en.wikipedia.org/wiki/Multiple_dispatch#Examples_of_emulating_multiple_dispatch

在旁注中，通过dynamic来电，在C＃中可以实现这一点：How to build double dispatch using extensions

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

Java中的多态未经证实的方法调用（adhoc多态）

1 个答案: