你能"dynamically bind"重载的方法吗？

Question

public class ConstructorOverloading {
static class A{
final String msg;
public A(Object o){
this.msg = "via object";
}
public A(Integer i){
this.msg = "via integer";
}
}
public A aWith(Object o){return new A(o);}
public A aWith(Integer i){return new A(i); }

static class B{
final String msg;
public B(Object o){
this.msg = "via object";
}
public B(Integer i){
this.msg = "via integer";
}
}
public <T> B bWith(T it){return new B(it);}
public void test(){
A aO = aWith(new Object());
A aI = aWith(Integer.valueOf(14));
B bO = bWith(new Object());
B bI = bWith(Integer.valueOf(14));
System.out.println(format("a0 -> %s", aO.msg));
System.out.println(format("aI -> %s", aI.msg));
System.out.println(format("b0 -> %s", bO.msg));
System.out.println(format("bI -> %s", bI.msg));
}
}

给我们

a0 -> via object
aI -> via integer
b0 -> via object
bI -> via object

我想这将是由于类型擦除。

我可以在不必插入显式类型检查或重载bWith的情况下对此做任何事情吗？

我的意思是，应用程序在运行时知道它应该使用Integer类型参数调用构造函数，它只是不知道调用正确的构造函数，毕竟......

另外 - 因为我猜测答案是否定的 - 允许这样的事情有什么问题？

Answer 1

我的意思是，应用程序在运行时知道它应该使用 Integer 类型参数调用构造函数，它只是不知道调用正确的构造函数，毕竟......

不，它没有。

此方法：

public <T> B bWith(T it){return new B(it);}

必须能够处理任何参数：编译器必须选择要在该方法中调用的单个构造函数。唯一满足该标准的构造函数是Object构造函数。

在运行时使其以不同方式执行的唯一方法是使用显式强制转换(您也可以删除类型参数，它是多余的(：

public B bWith(Object it){
if (it == null || it instanceof Integer) {
return new B((Integer) it);
}
return new B(it);
}

编辑：添加了it == null检查，因为new B(null)实际上会调用Integer构造函数，因为它是两者中更具体的。