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

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

如果不使用反射，您正在寻找的动态调度类型在 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 方法来避免整个问题在具体的子类中。

Answer 2

你实际上是在正确的轨道上，在这种情况下你确实需要使用反射。您正在寻找的是双重调度，因为您想要对 stuff 参数的动态类型进行分派。

这种类型的动态切换并不像您想象的那么罕见。例如，请参阅 此 javaworld 提示，它反映了 访客模式

Answer 3

编译器的抱怨是有充分理由的。无法保证您的 GeneralStuff 对象是 IntStuff 或 DoubleStuff。它可以是普通的 GeneralStuff 或 GeneralStuff 的任何其他扩展，这种情况您也没有在 process 方法中使用 < code>instanceof （除非返回空的String 是所需的行为）。

是否无法将该 process 方法移至 GeneralStuff 类中并在扩展中覆盖它？

另一种可能的解决方案是使用一种复合 ProcessStuff 类，在其中插入 IntStuffProcess、DoubleStuffProcess, ... 实例。这些实例中的每一个仍将进行instanceof检查，以决定它们是否可以处理传递给它们的GeneralStuff对象，但这至少比一个大的instanceof构造更具可扩展性/可维护性

Answer 4

也许，最好在 ProcessStuff 中重载 process 方法：

public class ProcessStuff {

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

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

Answer 5

将 GeneralStuff 定义为抽象类，并在继承类中填充 doProcess 方法（抽象）。这样您就可以避免所有有关 instanceof 值等的问题。或者你可以按照 βнɛƨн Ǥʋяʋиɢ 的建议进行操作，但是你仍然必须为每个特定类定义一个重载，而在我的方法中你只需直接调用它。

所以我的建议是：
公共抽象类 GeneralStuff {
私有 int ID；

    public abstract String process();
}

public class IntStuff extends GeneralStuff {
    private int value;

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

    public int getValue()
    {
        return value;
    }

    @override
    public String process(){
        return String.format("%d", getValue());
    }
}

public class DoubleStuff extends GeneralStuff {
    private double value;

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

    public double getValue()
    {
        return value;
    }

    @override
    public String process(){
        return String.format("%f", 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(iS.process());
        System.out.println(dS.process());
    }
}