两个初始化之间有什么区别：Object x = new String（）; String x = new String（）;

Question

what's the difference between the two initialization:

Object x = new String(); 
String x = new String();

in java

thank!

Answer 1

Object x = new String(); // pointing to a String and saying - Hey, Look there! Its an Object
 String x = new String();// pointing to a String and saying - Hey, Look there! Its a String

More importantly : The methods of String that can be accessed depend on the reference. For example :

public static void main(String[] args) {
    Object o = new String();
    String s = new String();
    o.split("\\."); // compile time error
    s.split("\\."); // works fine

}

Answer 2

初始化没有区别，只在声明中 ，因此代码的其余部分看到变量类型。

Answer 3

The difference is that in the first option x will be considered by the compiler as an Object and in the second it'll be considered as a String. Example:

public static void main (String[] args) throws Exception {

    Object x = new String();
    test(x);
    String y = new String();
    test(y);
    // and you can also "trick" the compiler by doing
    test((String)x);
    test((Object)y);
}

public static void test(String s) {
    System.out.println("in string");
}

public static void test(Object o) {
    System.out.println("in object");
}

will print:

in object
in string
in string
in object

Answer 4

Object x = new String(); 

here, x has access only to the Object 's methods and members. (To use String members, you have to typecast the x to String (using Downcasting in Java ))

String x = new String();

here, x has access to all the methods and members of Object as well as String .

Answer 5

Both are same, X will refer to the string object.

But x variable in Object x = new String(); need to be Type casted to String , using x.toString() or (String)x before making use of it.

Answer 6

As noted by the other answerers, both cases will result in the variable x holding a reference to a String. The only difference is how subsequent code will see the reference: as an Object vs String, ie determining which operations the compiler will allow on the reference.

Essentially, the question highlights the difference between a statically typed language (eg Java) and a dynamic one (eg Python, Javascript, etc.). In the latter you don't have to declare the type of the reference, so the code for this is simply something like:

var x = new String();

In this case, the compiler infers the type at runtime , but you lose some static type checking at compile time .

In everyday Java code you will always use the form:

String x = new String();

since that will allow you to treat x like a String and call, eg the method toUpperCase() on it. If x were an Object , the compiler won't allow you to call that method, only Object methods, eg equals() .

However, the exact opposite is true in the following case:

List list = new ArrayList();
ArrayList list = new ArrayList();

Unless you specifically want to use methods exposed by ArrayList (unlikely), it is always better to declare list as a List , not ArrayList , since that will allow you to change the implementation to another type of List later, without changing the calling code.

Answer 7

Difference is you need to cast it a lot however you can use the same variable and reinitialize it with another type. It is very usefull when you are working with changing variables..

Example:

Object x = new String();
if(x instanceof String){
    System.out.println("String");
}
x = new ArrayList<String>();
if(x instanceof ArrayList){
    System.out.println("ArrayList");
}

returns:

String ArrayList