为什么等于不使用强制转换的equals方法？

Question

Simply the just as the question have stated. The answer should ideally be false, since it would be using the Object#equal which is simply reference comparison.

    String cat = new String("cat");
    String cat2 = new String("cat"); 

    System.out.println(((Object) cat).equals((Object) cat2)); // returns true, but should be false

This has to do with polymorphism; I know how equals() and interning work.

RELATED TOPICS: CASTING GRAPHICS -> GRAPHICS2D

The aforementioned scenario is a case of upcasting where String is being downcasted to Object.

However, a common use of this is actually downcasting Graphics to Graphics2D to use upgraded or new method that don't exist in Graphics itself. How come we can upcast and NOT downcast.

import java.awt.*;
import javax.swing.*;

    public class Example extends JPanel {
        public static void main (String []args){
        JFrame frame = new JFrame();
    }
    public void paintComponent(Graphics g){
        Graphics2D g2 = (Graphics2D) g;             // How can we be sure the informal 
        g2.drawLine(0,0, getWidth(), getHeight());  // parameter contains those methods?
    }
}

Answer 1

You cast cat to Object , but that doesn't change the fact that cat is a String instance . Java performs dynamic binding (aka late binding), meaning that method invocations are resolved at runtime based on the class of which the object is an instance. In this case, that's still String , which means String#equals() will be used, not Object#equals() . The fact that you cast cat2 to Object makes little difference -- equals() takes an Object argument anyway.

Here's an easy way to prove this to yourself:

String s = "abc";
Object o = (Object) s;  // we don't really need an explicit cast

System.out.println(s.getClass());
System.out.println(o.getClass());

class java.lang.String
class java.lang.String

The same principle is at work here. o is of type Object but it is a String instance, and so String 's getClass() is called.

---

Consider the following class structure:

class A {
    public void foo() {
        System.out.println("A foo");
    }
}

class B extends A {
    public void foo() {
        System.out.println("B foo");
    }

    public void bar() {
        System.out.println("B bar");
    }
}

Now, when we have something like

A b = new B();
b.foo();

then B 's foo method will be invoked. This is the phenomena described above. You're asking about something like:

A b = new B();
b.bar();  // error

The reason we have an error here is because there is no guarantee that b will have a bar() method. For all we know (or, rather, the compiler knows), b could be a C instance with who-knows-what. For this reason, we have to perform an explicit cast:

A b = new B();
((B) b).bar();    

This follows from the fact that Java is statically typed (even though it performs dynamic binding).

Answer 2

Instance methods are resolved at run time based on their dynamic type. This is polymorphism/late binding. Regardless of you casting the object to a static type of Object , it's runtime type is still String , so String#equals(Object) will be used.

How come we can upcast and NOT downcast.

Given two classes

public class A {

}

public class B extends A {
    public void doSomething() {}
}

and

A a = new B();
a.doSomething(); // this won't compile because A doesn't declare a doSomething() method
((B) a).doSomething(); // this is fine because you are now calling the method on the static type B
// you might get a ClassCastException here if the runtime type of a wasn't B

Answer 3

As all the methods are default virtual in java so even though you type casted it to Object it will call String equals method because the object is of type String not of Object .

This is also called late binding or runtime polymorphism.

Answer 4

That's not how Java resolves which method should be used. Even though you are casting it to Object at runtime String's equals will be used. And String's equals doesn't check reference equality but if the strings are "logically" equal.

This is due to so called "dynamic linking" you can google it or try reading about it here.

Answer 5

String Object is one of the immutable objects, others like Integer.

So here is a simple comparison, you created 2 Integer objects(the same value) and do equal operation. It makes more sense returning the 2 Integers are equal.

And from the example, I guess you might now know the objective of immutable classes: they are designed to retain their state and simplify operations relate to them, just like an int.