java - 使用通用父类型输入参数强制执行动态多态调用

Question

我正在尝试使用多态性来根据类对对象进行不同的处理，如下所示:

public class GeneralStuff {
    private int ID;
}

public class IntStuff extends GeneralStuff {
    private int value;

    public void setValue(int v)
    {
        value = v;
    }

    public int getValue()
    {
        return value;
    }
}

public class DoubleStuff extends GeneralStuff {
    private double value;

    public void setValue(double v)
    {
        value = v;
    }

    public double getValue()
    {
        return value;
    }
}

public class ProcessStuff {

    public String process(GeneralStuff gS)
    {
        return doProcess(gS);
    }

    private String doProcess(IntStuff i)
    {
        return String.format("%d", i.getValue());
    }

    private String doProcess(DoubleStuff d)
    {
        return String.format("%f", d.getValue());
    }
}


public class Test {
    public static void main(String[] args)
    {
        IntStuff iS = new IntStuff();
        DoubleStuff dS = new DoubleStuff();
        ProcessStuff pS = new ProcessStuff();

        iS.setValue(5);
        dS.setValue(23.2);

        System.out.println(pS.process(iS));
        System.out.println(pS.process(dS));
    }
}

然而，这不起作用，因为调用 doProcess(gS) 需要一个带有签名 doProcess(GeneralStuff gS) 的方法。

我知道我可以在 ProcessStuff 类中只公开两个多态过程方法，但实际情况不允许这样做，因为我在现有库机制的约束下工作；这只是一个人为的测试示例。

当然，我可以将 process(GeneralStuff gS) 定义为

public String process(GeneralStuff gS)
{
    if (gS instanceof IntStuff)
    {
        return doProcess((IntStuff) gS);
    }
    else if (gS instanceof DoubleStuff)
    {
        return doProcess((DoubleStuff) gS);
    }
    return "";
}

这行得通，但似乎我不应该那样做(另外，编程警察会因为我以这种方式使用 instanceof 而串起我)。

有没有一种方法可以更好地执行多态调用？

在此先感谢您的帮助。

Answer 1

如果不使用反射，您正在寻找的动态分派(dispatch)类型在 Java 中是不可能的。 Java 根据声明的类型在编译时进行链接(因此即使方法被重载，实际调用的方法也是基于变量的声明类型而不是运行时类型)。

因此，您只能按照您的建议使用 instanceof，使用反射，或者将过程方法放在对象本身中(这是“oop”方法，但通常不合适或不可取)。

一个潜在的替代方案是按类创建处理对象的映射，例如:

Map<Class<? extends GeneralStuff>,Processor> processors;

public String process(GeneralStuff stuff)
{
  Processor processor = processors.get(stuff.getClass());
  if (processor != null)
  {
    return processor.process(stuff);
  }
}

public interface Processor
{
  public String process(GeneralStuff stuff);
}

public class IntegerProcessor implements Processor
{
  public String process(GeneralStuff stuff)
  {
    return String.format("%i",((IntegerStuff) stuff).getValue());
  }
}

但是，对于您的特定示例，String.format 将对象作为参数，因此您可以通过在 GeneralStuff 中使用 getValue 和 getFormatString 方法来避免整个问题，这些方法在特定子类中被覆盖。