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

Question

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.?

Answer 1

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.

Answer 2

Concepts you ask about are covered in Java tutorials.

Explanation for overriding is given as follows:

An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclass overrides the superclass's method.

The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This is called a covariant return type.

When overriding a method, you might want to use the @Override annotation that instructs the compiler that you intend to override a method in the superclass. If, for some reason, the compiler detects that the method does not exist in one of the superclasses, it will generate an error. For more information on @Override, see Annotations...

Overloading is explained in tutorial as follows:

The Java programming language supports overloading methods, and Java can distinguish between methods with different method signatures. This means that methods within a class can have the same name if they have different parameter lists (there are some qualifications to this that will be discussed in the lesson titled "Interfaces and Inheritance".

Suppose that you have a class that can use calligraphy to draw various types of data (strings, integers, and so on) and that contains a method for drawing each data type. It is cumbersome to use a new name for each method—for example, drawString, drawInteger, drawFloat, and so on. In the Java programming language, you can use the same name for all the drawing methods but pass a different argument list to each method. Thus, the data drawing class might declare four methods named draw, each of which has a different parameter list...

Overloaded methods are differentiated by the number and the type of the arguments passed into the method...

You cannot declare more than one method with the same name and the same number and type of arguments, because the compiler cannot tell them apart.

The compiler does not consider return type when differentiating methods, so you cannot declare two methods with the same signature even if they have a different return type.

---

Note: Overloaded methods should be used sparingly, as they can make code much less readable.

---

Above explanation for overloading mentions qualifications discussed in the lesson titled "Interfaces and Inheritance":

In a subclass, you can overload the methods inherited from the superclass. Such overloaded methods neither hide nor override the superclass methods—they are new methods, unique to the subclass.

Answer 3

Overloading, methods have the same name but different parameters.

Overriding, the implementation given in base class is replaced with that in sub class.

Answer 4

Overloading a method is typically defined as "providing multiple available methods with the same name, differing by the number and type of inputs and outputs". The concept is usually that you want to be able to perform the same basic operation given varying sets of inputs: you can, for instance, "add" any two values of numeric type, however it is usually important to know what the exact type of the value is so that you can take advantage of or plan for specific behaviors of that type. As such, you would define a method for each combination of numeric types (and or collections) you wish to support. All these methods have the same name, but different "signatures"; at compile-time, the compiler will match a call to a particular method name with a given combination of inputs to a specific pointer in the application memory used to store code.

Overriding a method is typically defined as "providing a different implementation in a derived class of a method with a particular signature defined in the base class". There are many reasons to override a method; virtually all of them have in common the fact that the derived class has additional knowledge of what must be done, which cannot be known by the base class. There are two flavors of overriding in most OO languages; overriding can replace the base class method, or it can extend the base class method. The difference is usually that a derived class that is extending a base class implementation will call the base class's overridden version of the method at some point during the execution of the overriding method. This allows overriding classes to "re-use" common areas of the operation which are contained in the base class.

Answer 5

Overloading is where you provide multiple methods with the same name, but different type and number of arguments. The compiler distinguishes two methods with the same name only on basis of arguments, if they have the same set of arguments, but a different return type, it would still take them as the same name.

For eg

public int getTotal(int a,int b)

public int getTotal(float a,float b) is overloading.

But

public int getTotal(int a,int b)

public float getTotal(int a,int b) is not overloading.

Overriding is a concept we use in inheritance, where we have a method in the derived class, that has the same name and signature as the method in base class, but with a different implementation. We use overriding in cases, when we have a Generic functionality which can be implemented dynamically as per requirement. What the overriden method does is either extend the existing generic functionality or replace the base class implementation with it's own implementation.

So let us say we have a super class Draw with a method that accepts two arguments and then draws a figure.

class Draw { public void draw(int x)

{ // Do something. }

}

Now we want to implement the draw functionality for Square,Circle,Cube.

class DrawSquare extends Draw

{

public void draw(int x) { // Do something. }

}

class DrawCircle extends Draw {

public void draw(int x) { // Do something. }

}

class DrawCube extends Draw {

public void draw(int x) { // Do something. }

}

Now the choice of calling the method is dependent on which object we choose.

So we have a test class say *TestDraw Now if you wish to say draw a Square.

public class TestDraw {

Draw ds=new DrawSquare(); ds.draw(10);

// To draw a circle

ds=new DrawCircle();

dc.draw(20);

}