Java – What’s the difference between overloading a method and overriding it in Java

javaobject-oriented

What's the difference between overloading a method and overriding it in Java?

Is there a difference in method signature, access specifier, return type, etc.?

Best Answer

To overload a method with a new method, the new method should have a different signature. I.e. two overloaded methods have the same name, but different parameters. Here's an example of two overloaded methods:

boolean isOdd(int number) { ... };
boolean isOdd(float number) { ... };

Based on the parameter types, the corresponding method will be called. Note that changing the return type is not enough (though you can do this additionally).

When a method is overridden, then the new method has the same signature and replaces the overridden method in some cases. Here's an example of an overridden method:

public class A 
{
     public void someMethod() { ... }
}

public class B extends A
{
     public void someMethod() { ... }
}

The choice is made based on the object type. For example,

A someA = new B();
someA.someMethod();

will call the someMethod of B. You can (and should) add the @Override annotation:

public class B extends A
{
     @Override
     public void someMethod() { ... }
}

Now, if you accidentally change the parameters in B, the compiler will inform you, that you are not overriding someMethod() but overloading it.

Related Solutions

Java – the difference between instantiating and loading a class in Java

In order for a class to be instantiated it has to be loaded by the classloader...in many cases this is the first time the class has been just-in-time compiled. If you access a static variable on a class, it has to be loaded. If you want to reflect on a class it has to be loaded. There are many circumstances where you might just load a class rather than instantiate.

Also the static initializer(s) for a class fire the first time the class is loaded (and before anything else). If you have an explicit static intializer you can use it to perform a global initialization if need be.

Java Programming – When is Method Overloading Appropriate?

You overload when you wish to support different types:

public overload void MyMethod(int value)
{ 
}

public overload void MyMethod(bool value)
{
}

public overload void MyMethod(string value)
{
}

or to support a progressive interface using different parameter lists:

public overload void MyOtherMethod()
{
    this.MyOtherMethod(DefaultValue);
}

public overload void MyOtherMethod(int value)
{
    this.MyOtherMethod(value, DefaultOtherValue);
}

public overload void MyOtherMethod(int value, bool otherValue)
{
    ...
}

You might even get a little crazy and support both different types AND a progressive interface, but you should bear in mind that you need to avoid creating variations in behaviour between overloaded methods. Each overloaded method should be functionally the same as the others in an overloaded group, otherwise it will be unclear as to how, when or why behaviour is being varied. If you want two functions to do something completely different, then you should name them accordingly.

Best Answer

Related Solutions

Java – the difference between instantiating and loading a class in Java

Java Programming – When is Method Overloading Appropriate?

Related Topic