Overloaded or overridden java

Difference between method Overloading and Overriding in java

In this tutorial we will discuss the difference between overloading and overriding in Java. If you are new to these terms then refer the following posts:

Overloading vs Overriding in Java

1. Overloading happens at compile-time while Overriding happens at runtime: The binding of overloaded method call to its definition has happens at compile-time however binding of overridden method call to its definition happens at runtime.
2. Static methods can be overloaded which means a class can have more than one static method of same name. Static methods cannot be overridden, even if you declare a same static method in child class it has nothing to do with the same method of parent class.
3. The most basic difference is that overloading is being done in the same class while for overriding base and child classes are required. Overriding is all about giving a specific implementation to the inherited method of parent class.
4. Static binding is being used for overloaded methods and dynamic binding is being used for overridden/overriding methods.
5. Performance: Overloading gives better performance compared to overriding. The reason is that the binding of overridden methods is being done at runtime.
6. private and final methods can be overloaded but they cannot be overridden. It means a class can have more than one private/final methods of same name but a child class cannot override the private/final methods of their base class.
7. Return type of method does not matter in case of method overloading, it can be same or different. However in case of method overriding the overriding method can have more specific return type (refer this).
8. Argument list should be different while doing method overloading. Argument list should be same in method Overriding.

Overloading example

//A class for adding upto 5 numbers class Sum < int add(int n1, int n2) < return n1+n2; >int add(int n1, int n2, int n3) < return n1+n2+n3; >int add(int n1, int n2, int n3, int n4) < return n1+n2+n3+n4; >int add(int n1, int n2, int n3, int n4, int n5) < return n1+n2+n3+n4+n5; >public static void main(String args[]) < Sum obj = new Sum(); System.out.println("Sum of two numbers: "+obj.add(20, 21)); System.out.println("Sum of three numbers: "+obj.add(20, 21, 22)); System.out.println("Sum of four numbers: "+obj.add(20, 21, 22, 23)); System.out.println("Sum of five numbers: "+obj.add(20, 21, 22, 23, 24)); >>

Sum of two numbers: 41 Sum of three numbers: 63 Sum of four numbers: 86 Sum of five numbers: 110

Here we have 4 versions of same method add . We are overloading the method add() here.

Overriding example

package beginnersbook.com; class CarClass < public int speedLimit() < return 100; >> class Ford extends CarClass < public int speedLimit() < return 150; >public static void main(String args[]) < CarClass obj = new Ford(); int num= obj.speedLimit(); System.out.println("Speed Limit is: "+num); >>

Here speedLimit() method of class Ford is overriding the speedLimit() method of class CarClass .

Top Related Articles:

About the Author

I have 15 years of experience in the IT industry, working with renowned multinational corporations. Additionally, I have dedicated over a decade to teaching, allowing me to refine my skills in delivering information in a simple and easily understandable manner.

Comments

hi sir,
I’m not sure whether I’m correct i studied both method overloading and overridding then I’m studying there difference..i think the 7th point is incorrect.. it states “Return type of overloaded method should be same as the other methods of the same name however return type of overriding method can be different from overridden method.” and i think it must be ” the return type of overloading methods can differ but the return type of overriding methods should be the same..”… if im wrong plz help me to identify my mistake .
thank u so much

Hello Jemima, Point#7 is correct, overridden methods can have different return types. You can refer http://stackoverflow.com/questions/14694852/can-overridden-methods-differ-in-return-type.

For the 7th point `Return type of overloaded methods should be same`. Is it always necessary for methods to be overloaded?
What about this example? public String getData() return “Employe from Manager”;
>
public int getData(String val) return 0;
>

Can u please explain me 7th point ? I think it is wrong right? return type doesn’t matter in case of overloading and return type should be same for method overriding.

Источник

Overriding vs Overloading in Java

Overriding and overloading are the core concepts in Java programming. They are the ways to implement polymorphism in our Java programs. Polymorphism is one of the OOPS Concepts.

When the method signature (name and parameters) are the same in the superclass and the child class, it’s called overriding. When two or more methods in the same class have the same name but different parameters, it’s called overloading.

Comparing overriding and overloading

Overriding	Overloading
Implements “runtime polymorphism”	Implements “compile time polymorphism”
The method call is determined at runtime based on the object type	The method call is determined at compile time
Occurs between superclass and subclass	Occurs between the methods in the same class
Have the same signature (name and method arguments)	Have the same name, but the parameters are different
On error, the effect will be visible at runtime	On error, it can be caught at compile time

Overriding and overloading example

Here is an example of overloading and overriding in a Java program:

package com.journaldev.examples; import java.util.Arrays; public class Processor  public void process(int i, int j)  System.out.printf("Processing two integers:%d, %d", i, j); > public void process(int[] ints)  System.out.println("Adding integer array:" + Arrays.toString(ints)); > public void process(Object[] objs)  System.out.println("Adding integer array:" + Arrays.toString(objs)); > > class MathProcessor extends Processor  @Override public void process(int i, int j)  System.out.println("Sum of integers is " + (i + j)); > @Override public void process(int[] ints)  int sum = 0; for (int i : ints)  sum += i; > System.out.println("Sum of integer array elements is " + sum); > > 

Overriding

The process() method and int i, int j parameters in Processor are overridden in the child class MathProcessor . Line 7 and line 23:

public class Processor  public void process(int i, int j)  /* . */ > > /* . */ class MathProcessor extends Processor  @Override public void process(int i, int j)  /* . */ > > 

And process() method and int[] ints in Processor are also overridden in the child class. Line 11 and line 28:

public class Processor  public void process(int[] ints)  /* . */ > > /* . */ class MathProcessor extends Processor  @Override public void process(Object[] objs)  /* . */ > > 

Overloading

The process() method is overloaded in the Processor class. Lines 7, 11, and 15:

public class Processor  public void process(int i, int j)  /* . */ > public void process(int[] ints)  /* . */ > public void process(Object[] objs)  /* . */ > > 

Conclusion

In this article, we covered overriding and overloading in Java. Overriding occurs when the method signature is the same in the superclass and the child class. Overloading occurs when two or more methods in the same class have the same name but different parameters.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Источник

Difference between Method Overloading and Overriding in Java

Method overloading and method overriding ( in other words, polymorphism) concepts are often tested in java interviews. Let us understand their differences with easy-to-follow examples.

It is worth remembering that method overloading happens within the same class, and method overriding happens when a Child class extends a Parent class.

Method overloading happens when we define two methods of the same name in the same class. Here are a few rules that we should keep in mind while overloading any method:

1.1. Method Arguments must be Different

First and most important rule to overload a method is to change the method signature. The method signature comprises the number of method arguments, type of arguments and order of arguments if there are multiple arguments.

In the following example, the method sum() is defined two times. Both methods accept two arguments. The first method takes arguments of type Integer, and the second method takes arguments of type Float and Integer. Here the number of method arguments is same, but their types are different.

public class Calculator < public Integer sum(Integer a, Integer b) < return a + b; >public Integer sum(Float a, Integer b) < return a.intValue() + b; >>

1.2. Method Return Types are Not Considered

The return type of the method is not part of the method signature, so only changing the return type of the method does not amount to method overloading.

In the following example, the methods accept similar arguments and their return types differ. It is an invalid code and gives a compiler error “‘sum(Integer, Integer)’ is already defined in ‘Calculator’“.

public class Calculator < public Integer sum(Integer a, Integer b) < return a + b; >public Double sum(Integer a, Integer b) < return new Double(a + b); >>

1.3. Thrown Exceptions are Not Considered

The exceptions thrown from methods are also not considered when overloading a method. So if the overloaded method throws the same exception, a different exception, or does not throw any exception, there is no effect at all on method overloading.

public class Calculator < public Integer sum(Integer a, Integer b) throws NullPointerException< return a + b; >public Integer sum(Integer a, Integer b) throws IllegalArgumentException < return a + b; >>

Method overriding happens when a child class overrides a method from the parent class. Always remember these rules when overriding a method in java.

2.1. Method Arguments must be Exactly Same

The method argument list in overridden and overriding methods must be exactly the same. If they don’t match, we have created a different method.

In the following example, the Parent and the Child classes have methods with the same name and exact same parameters list. It is a valid method overriding.

class Parent < public Integer sum(Integer a, Integer b) < return a + b; >> class Child extends Parent < public Integer sum(Integer a, Integer b) < return a + b; >>

2.2. Method Return Type can be Subtype in Child Class

The return type of the overriding method can be the child class of the return type declared in the overridden method.

In the following example, the method return type in Parent is Number, and in the Child class, it is Integer. It is a valid return type and thus considered the valid method overriding.

class Parent < public Number sum(Integer a, Integer b) < return a + b; >> class Child extends Parent < public Integer sum(Integer a, Integer b) < return a + b; >>

If we use the incompatible return type in the Child class, we will get the compiler error.

class Parent < public Number sum(Integer a, Integer b) < return a + b; >> class Child extends Parent < public String sum(Integer a, Integer b) < return a.toString() + b.toString(); >>

'sum(Integer, Integer)' in 'Child' clashes with 'sum(Integer, Integer)' in 'Parent'; attempting to use incompatible return type

2.3. Thrown Exception can be Subtype in Child Class

The overriding method can not throw a checked exception higher in the hierarchy than thrown by the overridden method.

For example, the overridden method in Parent class throws FileNotFoundException , the overriding method in Child class can throw FileNotFoundException ; but it is not allowed to throw IOException or Exception , because IOException or Exception are higher in the hierarchy.

class Parent < public String readFile(String file) throws FileNotFoundException < //. return null; >> class Child extends Parent < public String readFile(String file) throws IOException < //. return null; >>

In above code, we will get the compiler error:

'readFile(String)' in 'Child' clashes with 'readFile(String)' in 'Parent'; overridden method does not throw 'java.io.IOException'

Note that we can omit the exception declaration from the overriding method. It’s allowed and perfectly valid. Also, overriding method can throw any unchecked (runtime) exception, regardless of whether the overridden method declares that exception or not.

In following example, the overriding method omits the FileNotFoundException and declares the RuntimeException which is unchecked exception. This is valid method overriding.

class Parent < public String readFile(String file) throws FileNotFoundException < //. return null; >> class Child extends Parent < public String readFile(String file) throws RuntimeException < //. return null; >>

2.4. The private, static and final methods can not be Overridden

The private, static and final methods can not be overridden in java in any way.

• The private modifier restricts the method to class.
• The static members belong to the class object.
• The final keyword is used wth members that must not be overridden.

In the following example, Parent and Child classes declare the method with same name and parameters, But it is not method overriding. The readFile() is never accessible outside the Parent class.

class Parent < private String readFile(String file)< //. return null; >> class Child extends Parent < public String readFile(String file) < //. return null; >>

2.5. Overriding Method can not Reduce Access Scope

Also note that the overriding method can not reduce the access scope of the overridden method.

For example, if the overridden method in Parent class is protected, then the overriding method in Child class can not be private. It must be either protected (same access) or public (wider access).

class Parent < protected String readFile(String file)< //. return null; >> class Child extends Parent < public String readFile(String file) < //. return null; >>

3. How to Verify if Method Overriding is Correct

To verify that we are correctly overriding a method or not, simply use the annotation @Override on overriding method in the Child class. This will verify all the method overriding rules. If there is any issue in overriding, it will result in compile time error.

class Parent < protected String readFile(String file)< //. return null; >> class Child extends Parent < @Override public String readFile(String file) < //. return null; >>

That’s all for this simple yet important concept to brush your basics in core java and object-oriented programming.

Источник