Java对象赋值是什么意思？

Question

I have the following 2 classes :

class Animal {
    public static void staticMethod(int i) {
        System.out.println("Animal : static -- " + i);
    }

    public void instanceMethod(int i) {
        System.out.println("Animal : instance -- " + i);
    }
}

class Cat extends Animal {
    public static void staticMethod(int i) {
        System.out.println("Cat : static -- " + i);
    }

    public void instanceMethod(int i) {
        System.out.println("Cat : instance -- " + i);
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.staticMethod(1);                       // Cat : static -- 1
        myCat.instanceMethod(2);                     // Cat : instance -- 2
        System.out.println("");

        Animal myAnimal = myCat;
        Animal.staticMethod(3);                      // Animal : static -- 3 
        myAnimal.staticMethod(4);                    // Animal : static -- 4 [ ? ]
        System.out.println("");

        myAnimal.instanceMethod(5);                  // Cat : instance -- 5
    }
} 

And when I run Cat, I got the following results :

Cat : static -- 1
Cat : instance -- 2

Animal : static -- 3
Animal : static -- 4

Cat : instance -- 5

I can understand 1,2,3 and 5, but why #4 is not : " Cat : static -- 4 " ? My understanding would be like this :

myAnimal=myCat means "myAnimal" is now exactly the same as "myCat", so anywhere "myAnimal" apears, you can replace it with "myCat" and get the same result, because everything inside myAnimal is the same as everything inside myCat, therefore "myAnimal.staticMethod(4)" should be the same as "myCat.staticMethod(4)" and the output should be : "Cat : static -- 4", similiar to "myCat.staticMethod(1)" above.

But that doesn't seem to be the case, why ?

Answer 1

You declare myAnimal as Animal . Therefore a static method is called from that class too.

You should never call static methods (or access static fields) from an instance to prevent this kind of confusion.

Answer 2

The reason is that Java resolves static methods based on the type of the reference variable itself, and not polymorphically at run time, as happens with instance methods.

To expand a little bit, when you are doing Animal myAnimal = myCat , you are assigning a Cat reference to an Animal reference. This is acceptable, because a Cat is also an Animal , so anything that an Animal can do, a Cat can do also.

Furthermore, if you call an instance (that is, non static) method via the myAnimal reference, and the method is overriden in Cat , then the Cat version of the method is called, because that's why the method was overriden in the first place. Static methods, on the other hand, are never overriden. That's why they are "static", as in "non-dynamic". Meaning that static methods can be resolved by the compiler instead of having to rely on the runtime environment.

Answer 3

From Oracle docs :

8.4.8.2. Hiding (by Class Methods)

If a class C declares or inherits a static method m, then m is said to hide any method m', where the signature of m is a subsignature (§8.4.2) of the signature of m', in the superclasses and superinterfaces of C that would otherwise be accessible to code in C.

Example 8.4.8.2-1. Invocation of Hidden Class Methods

A class (static) method that is hidden can be invoked by using a reference whose type is the class that actually contains the declaration of the method. In this respect, hiding of static methods is different from overriding of instance methods. The example:

class Super {
            static String greeting() { return "Goodnight"; }
            String name() { return "Richard"; }
        }
        class Sub extends Super {
            static String greeting() { return "Hello"; }
            String name() { return "Dick"; }
        }
        class Test {
            public static void main(String[] args) {
                Super s = new Sub();
                System.out.println(s.greeting() + ", " + s.name());
            }
        }

produces the output:

Goodnight, Dick

because the invocation of greeting uses the type of s, namely Super, to figure out, at compile time, which class method to invoke, whereas the invocation of name uses the class of s, namely Sub, to figure out, at run time, which instance method to invoke.

Answer 4

Static means exactly that: the call is resolved statically (in your case, it is resolved based on the declared type of the variable , and the variable is a compile-time entity).

The result you expected would require that the call is resolved dynamically (polymorphically, based on the actual type of the referenced instance, and the instance is a runtime entity).

Answer 5

设置myAnimal = myCat时，指针myAnimal指向cat对象，但是当您尝试通过myAnimal指针访问静态方法时，它会从myAnimal声明为的类中访问静态方法。