覆盖和重载方法

Question

What does it mean by "Casting affects the selection of overloaded methods at compile time but not overridden methods"?

I read the following passage on "Overridden methods and dynamic binding" ( https://www.oreilly.com/library/view/learning-java-4th/9781449372477/ch06s01.html ) and I couldn't understand the last paragraph

"In a previous section, we mentioned that overloaded methods are selected by the compiler at compile time. Overridden methods, on the other hand, are selected dynamically at runtime. Even if we create an instance of a subclass our code has never seen before (perhaps a new class loaded over the network), any overriding methods that it contains are located and used at runtime, replacing those that existed when we last compiled our code.

In contrast, if we created a new class that implements an additional, more specific, overloaded method, and replace the compiled class in our classpath with it, our code would continue to use the implementation it discovered originally. This situation would persist until we recompiled our code along with the new class. Another effect of this is that casting (ie, explicitly telling the compiler to treat an object as one of its assignable types) affects the selection of overloaded methods at compile time but not overridden methods."

I couldnt understand the "Casting" line: "Another effect of this is that casting (ie, explicitly telling the compiler to treat an object as one of its assignable types) affects the selection of overloaded methods at compile time but not overridden methods."

Answer 1

That line is referring to the fact that

• overloaded versions of a method are chosen at compile time, based on the compile-time types of the arguments that you are passing; whereas
• overridden methods are chosen at run time, based on the classes of the objects on which you call each method.

To understand this distinction, consider a situation where you have both overrides and overloads, like this.

public class Person {
}
---------------------------------------------------------
public class Postman extends Person {
}
---------------------------------------------------------
public class Dog {
    public void barkAt(Person p) {
        System.out.println("Woof woof");
    }

    public void barkAt(Postman p) {
        System.out.println("Grrrr");
    }
}
---------------------------------------------------------
public class Rottweiler extends Dog {
    @Override
    public void barkAt(Person p) {
        System.out.println("I'm going to eat you.");
    }

    @Override
    public void barkAt(Postman p) {
        System.out.println("I'm going to rip you apart.");
    }
}

In this situation, we call one of these barkAt methods, like this.

Dog cujo = new Rottweiler();
Person pat = new Postman();
cujo.barkAt(pat);

Now in this particular case, it's the compiler that chooses whether cujo.barkAt(pat); calls a method like public void barkAt(Person p) or public void barkAt(Postman p) . These methods are overloads of one another.

To do this, the compiler looks at the type of the expression being passed to the method - that is, the variable pat . The variable pat is of type Person , so the compiler chooses the method public void barkAt(Person p) .

What the compiler doesn't do is choose whether it's the method from the Rottweiler class or the Dog class that gets called. That happens at run time, based on the class of the object on which the method gets called, NOT on the type of the variable that you call the method on.

So in this case, what matters is the class of the object called cujo . And in this example, cujo is a Rottweiler , so we get the overridden version of the method - the one defined in the Rottweiler class.

This example will print out I'm going to eat you .

To summarise:

• The overload is chosen at compile time based on the parameter type .
• The override is chosen at run time based on the object class .

Now, it's possible to use casting to change the compiler's choice of overload. It's not possible to use casting to change the run time choice of override. So, we could write

cujo.barkAt((Postman) pat);

This time, the parameter passed to the method is an expression of type Postman . The compiler chooses an overload accordingly, and this will print I'm going to rip you apart. .

Answer 2

Casting affects the selection of overloaded methods at compile time but not overridden methods

Overloaded methods are visible at compile time. But overridden methods becomes visible at runtime.

Thumb Rule:

Java calls the overridden methods based on contents of reference variable and not type of reference variables.

Below example is self explainatory. Hope it helps.

class Animal {
    public void speak() {
        System.out.print("Animal sounds/roars.");
    }
}

class Human extends Animal {
    @Override                     // Method is overridden
    public void speak() {
        System.out.print("Humans talking english.");
    }

    public void speak(String words) {         // Method is overloaded.
        System.out.print("We have brain. We are intelligent."+words);
    }
}

class Earth {
    public static void main(String a[]) {
        Animal a = new Animal();
        a.speak(); // Prints Animal sounds/roars.

        Human h = new Human();
        h.speak();    // Prints "Humans talking english."

        Animal a = h; // Cast to superclass reference variable. However, underlying object is of Human.
        a.speak();    // Prints "Humans talking english." because speak() is known by Animal at compile time. During runtime, 
                      // the object contains the human object and hence java calls human overridden method.

        a.speak("I want to be human."); // Compile time error as speak(..) is not known by Animal at compile time.

    }
}