Advertisement

---

Top

< Prev

Next >

In Java, when a class is inherited, you can override the definition of any of its existing accessible methods in its subclass by a feature known as method overriding. Hence in simple words, method overriding is overriding the definition of a superclass method in its subclass.

Besides other rules that we are going to explain for method overriding, one basic rule is that the superclass method being overridden must have the same name in the subclass as well.

Use of method overriding

The key benefit to method overriding is that you can alter the behaviour of a method inherited from a superclass and define its specification according to the need of a subclass.

A simple example of method overriding.

// Java - Example of method overriding 

class A				//superclass
{
public void name()		//method name() in class A 
{
	System.out.println("A");
}
}

class B extends A		//subclass of A
{
public void name() 		//method name() of class A is overridden in class B
{
	System.out.println("B");
}
}

In this example, class A is inherited by class B. The name() method of class A is returning A but when this method is inherited and overridden by class B, it is returning B.

Rules for method overriding -:

• In order to override a method with a new method, the argument list of an overriding method must match with the argument list of a method being overridden.



// Java - Example of method overriding 


class Maths
{
int num1, num2;

public int mathOperation(int a, int b)	//performing addition operation on two integers.
{
	num1=a;
	num2=b;
	return (num1+num2);
}
}


//Subtract class is inheriting Maths class.
class Subtract extends Maths
{
public int mathOperation(int a, int b)	//mathOperation is overridden to perform subtract operation on two integers.
{
	num1=a;
	num2=b;
	return (num1-num2);
}
}

class Override
{
public static void main(String... ar)
{
	Subtract ob = new Subtract();
	System.out.println(ob.mathOperation(5,2));
}
}





Output -:




3





Program Analysis



• A class Maths is inherited by a class Subtract and the method mathOperation() of class Maths is overridden in class Subtract.
• While the method mathOperation() in class Maths is performing addition of two integers, the mathOperation() in class Subtract is overridden to perform subtraction of two integers.
• The method mathOperation() in class Maths has two integers in its arguments, therefore, to successfully override this method in class Subtract, the method mathOperation() in class B also has two integers in its arguments.





Advertisement





• The return type of an overriding method must be the same or a subtype of the return type declared in a method being overridden.



// Java - Example of method overriding 


class A
{
public A returnObject()		//method returnObject() has return type A
{
	return new A();
}
}

class B extends A
{
public B returnObject()		//overriding method returnObject() has return type B(subtype of A)
{
	return new B();
}
}


Class B has extended class A and hence class B is a subtype of class A. Now, the returnObject() method of class A is overridden by class B, with its return type, B i.e. a subtype of class A.





• The access level of an overriding method cannot be more restrictive than the access level of a method being overridden, but the access level can be less restrictive.



// Java - Example of method overriding 

class A
{
public void showName()		//method showName() has "public" access
{
	System.out.println("A");
}
}

class B extends A
{
private void showName()		//overriding method showName has a more restrictive "private" access
{
	System.out.println("B");
}
}





Output -




Overriding3.java:11: error: method() in B cannot override method() in A
private void showMethod()
             ^
attempting to assign weaker access privileges; was public 


Class B has inherited class A and it is trying to override showName() it inherited from Class A. Method showName() in class A has public access whereas while overriding, showName() in class B is given private access, which is against the rule of overriding, hence a compile error is issued.





• Instance methods of a superclass can only be overridden if they are first inherited by its subclass. Hence, the private or final instance methods of a class cannot be overridden by any class, because they aren't inherited in the first place.



// Java - Example of method overriding 


class A					//superclass
{
private void showMethod()		//showMethod() has private access and it cannot be overridden.
{
	System.out.println("A");
}
}


class B extends A			//subclass
{
private void showMethod()		//creating a new method showMethod() in class B
{
	System.out.println("B");
}
}

class Override
{
public static void main(String... ar)
{
	B ob = new B();
	ob.showMethod();
}
}


The private members of a class are never inherited by any class that extends it. Class B has extended class A, though it may look like showMethod() is inherited and overridden by class B but it is not. Class B has rather defined a new method with private access and the same name and return type as showMethod() of class A.

Note: Only the instance variables and methods of a superclass with access level such as public, default(in the same package) and protected are inherited through inheritance and can be overridden.

Why method overriding is needed?

Method overriding is mainly used in a situation when we want to create a more specialized version of a generic(general) method inherited from a superclass, within a subclass.

Please share this article -

< Prev

Next >

< Overloading

Constructors in Java >

Advertisement