Java 字符串与对象类型构造函数

POJO：

public class App {
    public static void main(String[] args) {
        ConTest conTest = new ConTest(null);

    }

---

当我运行这段代码时，它总是调用具有

String

参数的构造函数。为什么？

null

可以传递给两个构造函数

但是，

字符串

参数比

对象

参数更具体（因为

字符串

是

对象

的一个子类），方法重载解析过程更喜欢具有更具体参数类型的方法（或构造函数）

如注释中所述，如果要强制调用接受

对象的构造函数

，可以将

null

强制转换为

对象

：

public class ConTest {

    private String  a;

    private Object  b;

    public ConTest(Object b) {
        System.out.println("Object" + b);
    }

    public ConTest(String a) {
        System.out.println("String :" + a);
    }

}

---

null

可以传递给两个构造函数

但是，

字符串

参数比

对象

参数更具体（因为

字符串

是

对象

的一个子类），方法重载解析过程更喜欢具有更具体参数类型的方法（或构造函数）

如注释中所述，如果要强制调用接受

对象的构造函数

，可以将

null

强制转换为

对象

：

public class ConTest {

    private String  a;

    private Object  b;

    public ConTest(Object b) {
        System.out.println("Object" + b);
    }

    public ConTest(String a) {
        System.out.println("String :" + a);
    }

}

---

这是因为存在多个适合调用的拟合方法（本例中为构造函数）。如果一个方法调用有多个fitting方法，则始终采用最具体的方法。在这种情况下，

String

比

Object

更具体。 这可以在继承链中看到<代码>字符串继承自

对象

如果有两个同样特定的方法，那么编译器将通过错误消息

告诉您，类型类的方法（参数）不明确。这可以在这个例子中看到

ConTest conTest = new ConTest((Object)null);

稍微改变一下，通过让
B
从
a
继承，方法
test（B）
变得更具体，因为
B
比
a
更具体，编译器错误消息也消失了

public class A { 
    public static void main(String[] args) {
        // compiler complains with:
        // The method test(Object) is ambiguous for the type A
        test(null); 
    }

    static void test(Object o) {
        System.out.println("IN OBJECT");
    }

    static void test(A a) {
        System.out.println("IN A");
    }

    static void test(B b) {
        System.out.println("IN B");
    }

    class B {

    }
}

这是因为存在多个适合调用的拟合方法（本例中为构造函数）。如果一个方法调用有多个fitting方法，则始终采用最具体的方法。在这种情况下，
String
比
Object
更具体。
这可以在继承链中看到<代码>字符串

继承自

对象

如果有两个同样特定的方法，那么编译器将通过错误消息

告诉您，类型类的方法（参数）不明确。这可以在这个例子中看到

ConTest conTest = new ConTest((Object)null);

稍微改变一下，通过让
B
从
a
继承，方法
test（B）
变得更具体，因为
B
比
a
更具体，编译器错误消息也消失了

public class A { 
    public static void main(String[] args) {
        // compiler complains with:
        // The method test(Object) is ambiguous for the type A
        test(null); 
    }

    static void test(Object o) {
        System.out.println("IN OBJECT");
    }

    static void test(A a) {
        System.out.println("IN A");
    }

    static void test(B b) {
        System.out.println("IN B");
    }

    class B {

    }
}

要调用对象版本，可以强制转换参数：
new ConTest（（object）null）是，如果我想调用对象的构造函数，您的代码运行良好。据我所知，object是一个超级类。所以它应该调用对象构造函数。要调用对象版本，可以强制转换参数：
new ConTest（（object）null）是，如果我想调用对象的构造函数，您的代码运行良好。据我所知，object是一个超级类。所以它应该调用对象构造函数。我喜欢你的回答和解释！谢谢你这么好的解释。我喜欢你的回答和解释！谢谢你这么好的解释。谢谢你这么好的解释。谢谢你这么好的解释。