Scribd
Upload
28 views5 pages

Method Overriding

Method overriding in Java allows a subclass to provide a specific implementation of a method that is already provided by its parent class. The subclass overrides the parent's method by declaring a method with the same name, arguments and return type. This allows the subclass to define class-specific behavior while reusing parts of the parent class implementation. The document provides an example of method overriding and discusses the rules and advantages of overriding such as dynamic method dispatch.

Uploaded by

Iqŕa Nooŕ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
28 views5 pages

Method Overriding

Method overriding in Java allows a subclass to provide a specific implementation of a method that is already provided by its parent class. The subclass overrides the parent's method by declaring a method with the same name, arguments and return type. This allows the subclass to define class-specific behavior while reusing parts of the parent class implementation. The document provides an example of method overriding and discusses the rules and advantages of overriding such as dynamic method dispatch.

Uploaded by

Iqŕa Nooŕ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Method overriding in java with example

BY CHAITANYA SINGH | FILED UNDER: OOPS CONCEPT

Declaring a method in sub class which is already present in parent class is


known as method overriding. Overriding is done so that a child class can give its
own implementation to a method which is already provided by the parent class.
In this case the method in parent class is called overridden method and the
method in child class is called overriding method. In this guide, we will see what
is method overriding in Java and why we use it.

Method Overriding Example


Lets take a simple example to understand this. We have two classes: A child
class Boy and a parent class Human. The Boy class extends Human class. Both
the classes have a common method void eat(). Boy class is giving its own
implementation to the eat() method or in other words it is overriding
the eat() method.

The purpose of Method Overriding is clear here. Child class wants to give its own
implementation so that when it calls this method, it prints Boy is eating instead of
Human is eating.

class Human{
//Overridden method
public void eat()
{
System.out.println("Human is eating");
}
}
class Boy extends Human{
//Overriding method
public void eat(){
System.out.println("Boy is eating");
}
public static void main( String args[]) {
Boy obj = new Boy();
//This will call the child class version of eat()
obj.eat();
}
}
Output:

Boy is eating
Advantage of method overriding
The main advantage of method overriding is that the class can give its own
specific implementation to a inherited method without even modifying the
parent class code.

This is helpful when a class has several child classes, so if a child class needs to
use the parent class method, it can use it and the other classes that want to have
different implementation can use overriding feature to make changes without
touching the parent class code.

Method Overriding and Dynamic Method Dispatch


Method Overriding is an example of runtime polymorphism. When a parent class
reference points to the child class object then the call to the overridden method is
determined at runtime, because during method call which method(parent class or
child class) is to be executed is determined by the type of object. This process in
which call to the overridden method is resolved at runtime is known as dynamic
method dispatch. Lets see an example to understand this:

class ABC{
//Overridden method
public void disp()
{
System.out.println("disp() method of parent class");
}
}
class Demo extends ABC{
//Overriding method
public void disp(){
System.out.println("disp() method of Child class");
}
public void newMethod(){
System.out.println("new method of child class");
}
public static void main( String args[]) {
/* When Parent class reference refers to the parent class object
* then in this case overridden method (the method of parent class)
* is called.
*/
ABC obj = new ABC();
obj.disp();

/* When parent class reference refers to the child class object


* then the overriding method (method of child class) is called.
* This is called dynamic method dispatch and runtime polymorphism
*/
ABC obj2 = new Demo();
obj2.disp();
}
}
Output:

disp() method of parent class


disp() method of Child class
In the above example the call to the disp() method using second object (obj2) is
runtime polymorphism (or dynamic method dispatch).
Note: In dynamic method dispatch the object can call the overriding methods of
child class and all the non-overridden methods of base class but it cannot call the
methods which are newly declared in the child class. In the above example the
object obj2 is calling the disp(). However if you try to call the newMethod() method
(which has been newly declared in Demo class) using obj2 then you would give
compilation error with the following message:

Exception in thread "main" java.lang.Error: Unresolved compilation


problem: The method xyz() is undefined for the type ABC

Rules of method overriding in Java


1. Argument list: The argument list of overriding method (method of child
class) must match the Overridden method(the method of parent class). The
data types of the arguments and their sequence should exactly match.
2. Access Modifier of the overriding method (method of subclass) cannot be
more restrictive than the overridden method of parent class. For e.g. if the
Access Modifier of parent class method is public then the overriding method
(child class method ) cannot have private, protected and default Access
modifier,because all of these three access modifiers are more restrictive
than public.
For e.g. This is not allowed as child class disp method is more
restrictive(protected) than base class(public)
3. class MyBaseClass{
4. public void disp()
5. {
6. System.out.println("Parent class method");
7. }
8. }
9. class MyChildClass extends MyBaseClass{
10. protected void disp(){
11. System.out.println("Child class method");
12. }
13. public static void main( String args[]) {
14. MyChildClass obj = new MyChildClass();
15. obj.disp();
16. }
}
Output:

Exception in thread "main" java.lang.Error: Unresolved compilation


problem: Cannot reduce the visibility of the inherited method from MyBaseClass
However this is perfectly valid scenario as public is less restrictive than
protected. Same access modifier is also a valid one.

class MyBaseClass{
protected void disp()
{
System.out.println("Parent class method");
}
}
class MyChildClass extends MyBaseClass{
public void disp(){
System.out.println("Child class method");
}
public static void main( String args[]) {
MyChildClass obj = new MyChildClass();
obj.disp();
}
}
Output:

Child class method

17. private, static and final methods cannot be overridden as they are local to
the class. However static methods can be re-declared in the sub class, in
this case the sub-class method would act differently and will have nothing to
do with the same static method of parent class.
18. Overriding method (method of child class) can throw unchecked
exceptions, regardless of whether the overridden method(method of parent
class) throws any exception or not. However the overriding method should
not throw checked exceptions that are new or broader than the ones
declared by the overridden method. We will discuss this in detail with
example in the upcoming tutorial.
19. Binding of overridden methods happen at runtime which is known
as dynamic binding.
20. If a class is extending an abstract class or implementing an interface then
it has to override all the abstract methods unless the class itself is a abstract
class.

Super keyword in Method Overriding


The super keyword is used for calling the parent class
method/constructor. super.myMethod() calls the myMethod() method of base class
while super() calls the constructor of base class. Let’s see the use of super in
method Overriding.
As we know that we we override a method in child class, then call to the method
using child class object calls the overridden method. By using super we can call
the overridden method as shown in the example below:

class ABC{
public void myMethod()
{
System.out.println("Overridden method");
}
}
class Demo extends ABC{
public void myMethod(){
//This will call the myMethod() of parent class
super.myMethod();
System.out.println("Overriding method");
}
public static void main( String args[]) {
Demo obj = new Demo();
obj.myMethod();
}
}
Output:

Class ABC: mymethod()


Class Test: mymethod()
As you see using super keyword, we can access the overriden method.

You might also like