In Java, what’s the difference between method overloading and method overriding?

Overloading occurs when two or more methods in the same class share the same name. This can only occur when at least one of the following things is true:

1.) The number of parameters is different for the methods
2.) The parameter types are different.

What overloading is NOT

Overloading is not these 2 things:

1.  Changing the return type of the method
2.  Changing the name of the method parameters, but
    not changing the parameter types.

Here are some examples of where overloading would be both valid and invalid:

//compiler error - can't overload based on the
//type returned:    

int changeDate(int Year) ;
float changeDate (int Year);    

//compiler error - can't overload by changing just
//the name of the parameter:    

int changeDate(int Month) ;
float changeDate(int Year);    

//valid case of overloading, since there is an
//extra parameter in the first method:        

int changeDate(int Year, int Month) ;
int changeDate(int Year);    

//also a valid case of overloading, since the
//parameters are of different types:    

int changeDate(float Year) ;
int changeDate(int Year);

Subscribe to our newsletter on the left to receive more free interview questions!

Overriding is completely different. If a derived class requires a different definition for an inherited method, then that method can be redefined in the derived class. This would be considered overriding. An overridden method would have the exact same method name, return type, number of parameters, and types of parameters as the method in the parent class, and the only difference would be the definition of the method.

Let’s summarize the differences between overloading and overriding. When overloading, one must change either the type or the number of parameters for a method that belongs to the same class. But, overriding a method means that a method inherited from a base class is what’s being changed.

« Previous