What is the logic behind designing how Overloaded vs Overridden methods are invoked?

[Sandra Bachan]

Greetings,

I am studying for SCJP 6 Exam by reading

SCJP Sun® Certified Programmer for Java™ 6 Study Guide Exam (310-065)
By: Kathy Sierra; Bert Bates
Print ISBN-10: 0-071-59106-0


I am on Chapter 2, Overriding / Overloading (Exam Objectives 1.5 and 5.4). From what I understand, OVERLOADED methods are invoked based on the information received by compiler at compile time, while OVERRIDDEN methods are invoked based on information received by JVM at runtime. What is the LOGIC behind this design, why isn't it vice versa, i.e. OVERLOADED methods invoked at runtime, OVERRIDEN methods invoked based on information received by compiler.

[Prasad Kharkar]

The compiler does not check for everything at the compile time only
means the checking is superficial and compiler does not know what will happen at run time
At compile time , the type of the object is checked and at the run time the object is checked
Remember :

Which overloaded method to be called is decided at the compile time

Which overriden method to be called is decided at the run time

To make things clearer
you can take a look at the following code

 /* A Program to demonstrate the difference between Overriding and Overloading
Developer: Prasad Kharkar
*/
class Animal
{
	public void eat()	// original method
	{
		System.out.println("Animal"); 
	} // End of Method
}//End of class

public class Horse extends Animal
{
	public void eat()	// overriding the method in Animal class
	{
		System.out.println("Horse");
	}// End of method
	
	public void eat(String s)	// overloads the eat method in Animal
	{
		
		System.out.println("String");
	} // End of overloaded method

public static void main(String args[])
	{
		Animal a = new Animal();
		Horse h1 = new Horse();
		Animal ah = new Horse();	// object of Horse but reference of Animal class
		Horse h2 = new Horse();
		Animal a2 = new Animal();
		a.eat();				//prints Animal
		h1.eat();				//prints Horse
		ah.eat();				//prints Horse 
		h2.eat("A");			//prints String
	//	a2.eat("A"); // This was commented because the compiler throws an error that animal class cannot access the methods of horse class
	}
}

   

[Harpreet Singh janda]

The Logic is run time polymorphism.

[Prithvi Sehgal]

Hello

The choice of which overloaded method to call is made at compile time. Compiler looks at the reference type to decide which overloaded
method to call.

The choice of which overridden method to call is based on actual object type based at run-time. Polymorphism concept is applied here.

Hope this helps,

[Sandra Bachan]

I appreciate the clarifications, thank you all