Method overriding and method overloading in java

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.

Источник

Method Overloading vs Method Overriding in Java – What’s the Difference?

Mikael Lassa

In Java, method overloading and method overriding both refer to creating different methods that share the same name.

While the two concepts share some similarities, they are distinct notions with markedly different use cases. Having a firm grasp of them is important in building strong foundational Java skills.

In this post, we’ll explore the key rules of method overloading and overriding, as well as the differences between them.

What is Method Overloading in Java?

Overloading a method, in simple terms, means creating a different method with the same name in the same class, but with a different parameter list.

There can be many cases where you might need to handle different types of input for the same operation, and method overloading is one way to handle such cases.

For example, let’s say you want to create a method that performs an addition of two numbers. This calculation is designed to return a number as its output. If your method handles parameters of type int , attempting to call it by passing values of type double as arguments results in a compilation error.

For this reason, you might want to overload the method by creating a new version of that method that is able to handle a different type of input (in this case of type double ):

public class Calculator < public int sum(int a, int b) < return a + b; >public double sum(double a, double b) < return a + b; >>

In the example above, the sum() method is overloaded, because it is defined more than once within the same class, but with a different parameter list.

A method can also be overloaded by changing the number of parameters. On this basis, the following methods are also legal examples of how the sum() method can be overloaded, assuming they are placed within the same class:

public int sum(int a, int b, int c) < return a + b + c; >protected void sum()

Note that, as in some of the examples above, you can also change the return type or the access modifier, but this is not mandatory.

Key Rules of Method Overloading

Remember these rules when overloading a method:

• The overloaded and overloading methods must be in the same class (Note: this includes any methods inherited, even implicitly, from a superclass).
• The method parameters must change: either the number or the type of parameters must be different in the two methods.
• The return type can be freely modified.
• The access modifier ( public , private , and so on) can be freely modified.
• Thrown exceptions, if any, can be freely modified.

What is Method Overriding in Java?

Method overriding refers to redefining a method in a subclass that already exists in the superclass.

When you call an overridden method using an object of the subclass type, Java uses the method’s implementation in the subclass rather than the one in the superclass. For this reason, an understanding of the concept of inheritance in Java is important in order to get a good grasp of method overriding.

Any subclass can generally override any method from a superclass, unless a method is marked with the final or static keywords. The overriding method must not change the name and parameter list of the overridden method.

While not compulsory, it is good practice to use the @Override annotation when overriding a method: this annotation will check that the method is being overridden correctly, and will warn you if that’s not the case.

In the following example, you’ll see a class Car that extends the class Vehicle . The Car class overrides the move() method from the superclass, and this is made explicit by the use of the @Override annotation. The two methods are implemented differently in the method body.

class Vehicle < public void move() < System.out.println("The vehicle is moving"); >> class Car extends Vehicle < @Override public void move() < System.out.println("The car is moving"); >>

The choice of which version of move() will be called is based on the object type the method is being called on. Note that the version of the overridden method that is called is determined at runtime and is based on the object type, not the object reference.

This is illustrated in the following example, particularly in the third call to move() : while the method is called on an object reference on type Vehicle , the actual object is of type Car . The type of the object here is determined at runtime, and the version of the method that is called is therefore the one from the Car subclass.

public static void main(String[] args) < Vehicle vehicle = new Vehicle(); vehicle.move(); // Prints: The vehicle is moving Car car = new Car(); car.move(); // Prints: The car is moving Vehicle secondVehicle = new Car(); secondVehicle.move(); // Prints: The car is moving >

Key Rules of Method Overriding

Remember these rules when overriding a method:

• The parameter list must not change: the overriding method must take the same number and type of parameters as the overridden method – otherwise, you would just be overloading the method.
• The return type must not change (Note: if the method returns an object, a subclass of that object is allowed as the return type).
• The access modifier must be either the same or a less restrictive one (for example, if the overridden method is protected , you can declare the overriding method as public , but not private ).
• Thrown checked exceptions, if any, can be removed or reduced by the overriding method. This means that the overriding method can throw the same checked exception as the overridden method, or a subclass of that checked exception, but not a broader exception. This restriction does not apply to unchecked exceptions.

Conclusion

In this article we explored the main rules of method overloading and method overriding in Java. You saw that the main point of overloading a method is to change its parameter list in order to implement a different behaviour based on the arguments that are passed to it.

Overriding, on the other hand, refers to re-defining the same method, with the same parameter list, in a subclass in order to tailor its behaviour to the needs of the subclass.

These concepts are interlinked with some of the core object-oriented programming ideas, such as inheritance and polymorphism, so they’re fundamental in order to master Java. They can cause some confusion, especially for beginners, but having a firm understanding of the rules and the uses of these concepts should help developers write more efficient and readable code.

If you would like to read any of my other articles, you are welcome to check out my blog.

Источник