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型参数调用构造函数，只是不知道调用 right < / em>构造函数，毕竟...

而且-由于我猜答案是“否”-允许这样的问题会是什么问题？

Answer 1

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

不，不是。

此方法：

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

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

在运行时使它与众不同的唯一方法是显式强制转换（您最好删除type参数，这是多余的）：

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构造函数，因为这是两者中更具体的一个。

您可以“动态绑定”重载方法吗？

1 个答案: