java - 方法重载和多态性——什么是更简洁的方法？

Question

检查以下代码示例:

public class Test
{
    private void process(Instance1 obj)
    {
        System.out.println("Process Instance 1");
    }

    private void process(Instance2 obj)
    {
        System.out.println("Process Instance 2");
    }

    /* 
    COMMENT THIS OUT - I DON'T HAVE THIS CODE IN REAL LIST. Only here to prove point 3 below calls this
    private void process(SuperClass obj)
    {
        System.out.println("Process superclass");
    }
    */

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Test test = new Test();
        Instance1 instance1 = test.new Instance1();
        Instance2 instance2 = test.new Instance2();
        SuperClass instance3 = test.new Instance1();

        // test #1          
        test.process(instance1);
        // test #2          
        test.process(instance2);
        // test #3 (compiler error unless there is a process(SuperClass obj) call)
        test.process(instance3);
        // test #4                      
        if(instance3 instanceof Instance1)
            test.process((Instance1)instance3);
        else if(instance3 instanceof Instance2)
            test.process((Instance2)instance3);

    }

    abstract class SuperClass
    {
    }

    class Instance1 extends SuperClass
    {
    }

    class Instance2 extends SuperClass
    {
    }
}

这给出了输出:

Process Instance 1
Process Instance 2
Process superclass
Process Instance 1

我希望测试 #3 知道调用正确的函数，但它似乎没有。我想这是编译时的事情而不是运行时的事情。选项 #4 可行，但很难看，我希望有更好的方法。

更新:为了澄清这个问题...我有一个抽象类，其中存在两个具体实现。我想要的是在另一个类中有两个重载方法(每个具体类一个)并且能够在不执行任何 instanceof 丑陋的情况下调用它。据我所知，这是不可能的，因为这是一个编译时问题，编译器显然不知道它是什么具体类，因为它不是强类型的。

Answer 1

这不是多态性的问题。这是方法重载的问题。

当您将 instance3 传递给 process() 时，它将调用 process(SuperClass obj) 因为就 JVM 而言， instance3 是一个 SuperClass，因为您将其声明为。

如果您想要期望的行为(测试#3 打印出“流程实例 1”)，您应该像这样定义您的 process() 方法:

private void process(SuperClass obj)
{
    System.out.println("Process " + obj.name());
}

你的类是这样的:

abstract class SuperClass
{
    String name() {
        return "SuperClass";
    }
}

class Instance1 extends SuperClass
{
    String name() {
        return "Instance 1";
    }
}

class Instance2 extends SuperClass
{
    String name() {
        return "Instance 2";
    }
}

由于动态(或后期)方法绑定(bind)，这将起作用。