Java overloading and overriding

Question

We always say that method overloading is static polymorphism and overriding is runtime polymorphism. What exactly do we mean by static here? Is the call to a method resolved

Answer 1

Property Over-loading Overriding

Method Names -------------->must be Same----------------must be same

Arg Types------------------>must be Different(at least arg)

Method Signature

Return Type

Private,Static,Final

Access Modifier

try/Catch

Method Resolution

Answer 2

i agree with rachel, because in K&B book it is directly mentioned that overloading does not belong to polymorphism in chapter 2(object orientation). But in lots of places i found that overloading means static polymorphism because it is compile time and overriding means dynamic polymorphism because it s run time.

But one interesting thing is in a C++ book (Object-Oriented Programming in C++ - Robert Lafore) it is also directly mentioned that overloading means static polymorphism. But one more thing is there java and c++ both are two different programing languages and they have different object manipulation techniques so may be polymorphism differs in c++ and java ?

Answer 3

Your are right - calls to overloaded methods are realized at compile time. That's why it is static.

Calls to overridden methods are realized at run-time, based on the type on which the method is invoked.

On virtual methods wikipedia says:

In Java, all non-static methods are by default "virtual functions." Only methods marked with the keyword final are non-virtual.

final methods cannot be overridden, so they are realized statically.

Imagine the method:

public String analyze(Interface i) {
     i.analyze();
     return i.getAnalysisDetails();
}

The compiler can't overload this method for all implementations of Interface that can possibly be passed to it.

Answer 4

Method overloading means making multiple versions of a function based on the inputs. For example:

public Double doSomething(Double x) { ... }
public Object doSomething(Object y) { ... }

The choice of which method to call is made at compile time. For example:

Double obj1 = new Double();
doSomething(obj1); // calls the Double version

Object obj2 = new Object();
doSomething(obj2); // calls the Object version

Object obj3 = new Double();
doSomething(obj3); // calls the Object version because the compilers see the 
                   // type as Object
                   // This makes more sense when you consider something like

public void myMethod(Object o) {
  doSomething(o);
}
myMethod(new Double(5));
// inside the call to myMethod, it sees only that it has an Object
// it can't tell that it's a Double at compile time

Method Overriding means defining a new version of the method by a subclass of the original

class Parent {
  public void myMethod() { ... }
}
class Child extends Parent {
  @Override
  public void myMethod() { ... }
}

Parent p = new Parent();
p.myMethod(); // calls Parent's myMethod

Child c = new Child();
c.myMethod(); // calls Child's myMethod

Parent pc = new Child();
pc.myMethod(); // call's Child's myMethod because the type is checked at runtime
               // rather than compile time

I hope that helps

Answer 5

I don't think you can call overloading any sort of polymorphism. Overloaded methods are linked at compile time, which kind of precludes calling it polymorphism.

Polymorphism refers to the dynamic binding of a method to its call when you use a base class reference for a derived class object. Overriding methods is how you implement this polymorphic behaviour.

Answer 6

First, I want to discuss Run-time/Dynamic polymorphism and Compile-time/static polymorphism.

Compile-time/static polymorphism:- as its name suggests that it bind the function call to its appropriate Function at compile time. That means the compiler exactly know which function call associated to which function. Function overloading is an example of compile time polymorphism.

Run-time/Dynamic polymorphism:-In this type of polymorphism compiler don't know which functions call associates to which function until the run of the program. Eg. function overriding.

NOW, what are the function overriding and function overloading???

Function Overloading:- same function name but different function signature/parameter.

eg. Area(no. of parameter) 
        {     -------------
           ----------------
             return area;}

         area of square requires  only one parameter
         area of rectangle requires two parameters(Length and breadth)

function overriding:- alter the work of a function which is present in both the Superclass and Child class. eg. name() in superclass prints "hello Rahul" but after overring in child class it prints "hello Akshit"