Elaboration: Method overloading is a static/compile-time binding but not polymorphism. Is it correct to correlate static binding with polymorphism?

Question

Before I ask my question, let me to explain my understanding and opinion.

• By only Overriding we can't achieve polymorphism unless there is upcasting. And as it can only seen at runtime people might have named it as Run time ploymorphism. (I have no objection to call polymorphism as Run Time Polymorphism)
• I have objection to call method overloading as compile time polymorphism or polymorphism.

I agree that method overloading is static binding (compile time binding), but I can't see polymorphism in that.

According to the javadoc, there is only polymorphism. There is no compile time or run time polymorphism.

According to javadoc in a section called Defining Methods, it explains Overloading of Methods. But there is nothing about compile time polymorphism.

According to me:

If you put polymorphism in to category of Run time polymorphism, you can only see "compile time polymorphism" when you change your JDK version:

If you switch from a higher JDK version higher to a lower one, you will start seeing compilation errors. The same code behaving differently during compilation time, eg: lambda expression, diamond operator, string in switch case, generics etc.

Let me elaborate my opinion, my prediction about how run time polymorphism and compile time polymorphism came to blogs/tutorials:

Conversation1

Developer 1: Hey I read about polymorphism today. If you do coding to interface, you can achieve polymorphism. writing codes not tightly coupling to a class but instead writing it to interface by making loose coupling, calling a superclass method or interface method actually invokes method of subclass depending on instance passed.

Developer 2: Sorry, I didn't get you.

Developer 1: It's simple at run time which object instance you will pass, that instance method will be executed.

Developer 2: Ohh! Run Time. I got it.

Developer 1: Yes same piece of code, but at Run Time passed instances are different.

Developer 2: **Run Time! Okay, I got it.

Conversation2

Developer 2: Hey yesterday I've met Developer1, he was telling about some run-time polymorphism. By overriding methods in a sub-class we can achieve it.

Developer 3: Run time polymorphism by overriding methods? Then what is oveloading? Compile time polymorphism?

Developer 2: How do you say overloading as compile time polymorphism?

Developer 3: Because it is decided at compile time only.

Developer 2: Silent!

Polymorphism and coding to interface best example is java.sql:

java.sql.Connection conn = DriverManager.getConnection(DB_URL,USER,PASS);
java.sql.Statement stmt = conn.createStatement();
java.sql.ResultSet rs = stmt.executeQuery(sql);

The same piece of code behaves differently based on the Driver registered. This means, if we register the Mysql driver, due to polymorphism this code executes methods of mysql instances. I.e. it executes overridden methods. If you register the Oracle driver, it works for Oracle, and so on.

Above we found same code behaving differently.

Now can anyone show me same code behaving differently in compile time. Or in other words show me add(3,4) method bounded to different methods (other signatured methods) during compile time?

According to javadoc,

The Java programming language supports overloading methods, and Java can distinguish between methods with different method signatures.

The method will be executed depending on signature matched. Having same name for methods does not mean there is a polymorphism, because calling methods signature is different:

Queestion1: If you won't change calling method signature will it call different method other than method for which signature has matched? In any condition will it behave differently?

Let's look at Method overloading:

public void add(int a, int b)
{
    System.out.println(a+b);
}

public void add(int a, int b, int c)
{
    System.out.println(a+b+c);
}

public static void main(String[] args)
{
    add(3,4);
    add(3,4,5);
}

Question 1: If method overloading is polymorphism, Which piece of code behaving differently in above block of code? Where is polymorphism here?

Question 2: Method invocation add(3,4); on what scenario it shows ploymorphism, unless it is modified to add(3,4,5)?

---

EDIT
@FutureVisitor since this thread found no answers in favor of method overloading as a type of polymorphism(Even after a month of question being asked), without any justification accepting answer in favor of Method overloading is not a polymorphism, if any answer points problem in my argument of method overloading is not polymorphism will be accepted and supported their views.

Answer 1

In the Java world, polymorphism means polymorphism between classes. I.e. refering possibly multiple child classes with their common parent. In Java, there is no polymorphism between methods.

void add(int a, int b) and void add(int a, int b, int c) are entirely different methods in the Java syntax. It shouldn't be so - for example, in C++, you can cast them to each other -, but it is so in Java.

The key concept to understand here is the method signature. The method signature defines in a language, what identifies the induvidual methods. (For example, beside a void add(int a, int b);, you simply can't declare an int add(int a, int b); method - the return value is not a part of the method signature in Java, thus the compiler would interpret it as a method re-definition.)

Answer 2

People says

1. overriding is run time polymorphism and
2. overloading is compile time polymorphism.
   

Both are wrong.
Only Overriding is not polymorphism. But overriding helps to achieve ploymorphism. If there is no upcasting you can't achieve ploymorphism.

Overloading is a concept where method-name along with argument signature are used to bind method call to method body and it can be predicted during compile time only. But this is nowhere related to polymorphism. There is NO behavioral change can be found in case of method overloading. Either you compile today or compile after one year behavioral change can only found if you change calling method signature i.e, only if you modify code say add(3,4); to add(3,4,5); and hence method overloading is not polymorphism.