具有多种类型支持的 Java 泛型

Question

假设我们有一个这样的接口...

接口 ICalculator{ 无效计算（T obj）； }

其中我们的泛型类型是一个抽象类...

public abstract class CalculableObject{...}

具有多个具体类型...

public class TypeA extends CalculableObject{.. .}

public class TypeB extends CalculableObject{...}

如果需要为多个 CalculableObject 类型定义计算方法，您将如何定义 Calculator 对象的实现？

即 -

public CalculatorAB;实现 ICalculator{
void 计算(TypeA obj){...}
void 计算(TypeB obj){...}
}

Answer 1

由于类型擦除，你不能。请参阅：通用接口出现错误：接口观察者不能使用不同的参数多次实现：

我会做的是使用delgate并拥有CalculatorAB，但它根本不实现ICalculator，或者更好的是，让CalculatorAB实现ICalcuator。然后，您的方法可以检查 的实例并转发到适当的方法。

public CalculatorAB implements ICalculator<CalculableObject> {
  void calculate(CalculableObject obj){
    if(obj instanceof TypeA)
      calculate((TypeA)obj);
    else if(obj instanceof TypeB)
      calculate((TypeB)obj);
  }
  void calculate(TypeA obj){...}
  void calculate(TypeB obj){...}
}

Answer 2

我敢说，如果你想这样做，也许你的设计中的其他地方有问题。但除了已经提到的替代方案之外，您还可以仅使计算方法在接口中通用，而不是整个接口。那么子接口可以是通用的，也可以简单地定义您想要的新方法。

像这样：

public static abstract class CalculableObject{}

public static class TypeA extends CalculableObject{}
public static class TypeB extends CalculableObject{}
public static class TypeC extends CalculableObject{}

public interface ICalculator{
    <T extends CalculableObject> void calculate(T obj);
}

public static class CalculatorAB implements ICalculator{

    void calculate(TypeA obj){
        System.out.println("TypeA");
    }
    void calculate(TypeB obj){
        System.out.println("TypeB");
    }

    @Override
    public <T extends CalculableObject> void calculate(T obj) {
        System.out.println("CalculableObject");
    }
} 

public static void main(String args[]){
    TypeA a = new TypeA();
    TypeB b = new TypeB();
    TypeC c = new TypeC();

    CalculatorAB ab = new CalculatorAB();

    ab.calculate(a);
    ab.calculate(b); 
    ab.calculate(c);
}

这呈现

TypeA
TypeB
CalculableObject

Answer 3

你不能。 （与流行的看法相反，它可以相对容易地在没有运行时具体化的情况下实现。但事实并非如此。）

通常，“主”类型的多个子类型化是一个坏主意。拥有一个对象，该对象具有返回适当的计算器的方法（请不要使用匈牙利语！）。

Answer 4

使用 enum：

public enum Type extends CalculableObject {
    A
    {
        @Override
        public void doSomething() { }
    },
    B;
}

然后可以保证 Type 的 A 和 B 存在，并且它们都扩展CalculableObject。

这还使您能够简单地将 Type.A 作为 Type 或 传递给 calculate 方法CalculableObject，而不是将其与 A、B、C、D 等混杂在一起。

Answer 5

您可以在 CalculableObject 类中定义“计算”所需的方法。然后，在 CalculatorAB 中，您只需调用给定对象上的这些方法。