Advertisement

---

Top

< Prev

Next >

In C#, you can declare a method of a base class with the virtual keyword, which allows its derived class to redefine its definition i.e. when the class with virtual method is inherited.

Hence, in simple words, you can override the definition of base class methods marked with virtual keyword, in any of its derived classes, by a process known as method overriding.

To override the definition of a virtual method of the base class, we must use the override modifier, when the method is being overridden in the derived class.

Use of method overriding

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

Rules to method overloading -

• The name of the overriding method must match with the name of the virtual method being overridden.
• The return type of the overriding method must exactly match with the return type of the virtual method being overridden.
• The signature i.e. number and the type of arguments of an overriding method must match with the signature of virtual method being overridden.
• The access modifier of an overriding method must match with the access modifier of a virtual method being overridden.

• The name of the overriding method must match with the name of the virtual method being overridden.



//C# A simple example of method overriding 

using System;

//Base class
class A				
{
//Defining a method GetName() in class A with virtual keyword
//It will display the name of its class i.e. A 
public virtual void GetName()		
{
	Console.WriteLine("A");
}
}

//Derived class of A
class B:A		
{
//Overriding the method GetName() of class A in class B, with override keyword
//This overridden version will display the name of its class i.e. B
public override void GetName() 		
{
	Console.WriteLine("B");
}

public static void Main(String[] ar)
{
	//Creating an object of class B
	B ob = new B();
	
	//Calling the overridden method 
	//by using the object of class B
	ob.GetName();
}
}





Output




B



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





• The return type of the overriding method must exactly match with the return type of the virtual method being overridden.



//C# An Example of method overriding
//The return type of the overriding method 
//must match with the return type of the method being overridden.


using System;

//Base class
class A
{
//The method ReturnObject() has return type A
//and it is marked with a virtual keyword
public virtual A ReturnObject()		
{
	return new A();
}
}


//class B is inheriting class A i.e. derived class
class B:A
{
//Overriding the method ReturnObject() of class A in class B, with override keyword
//This overridden version also has the matching return type A
public override A ReturnObject()		
{
	return new B();
}

public static void Main(String[] ar)
{
	//Creating and object of class B
	B ob = new B();

	//Calling the overridden version of derived class, B
	//By using its object.
	Console.WriteLine(ob.ReturnObject());
}
}




Output




B


Class B has inherited class A and the method ReturnObject() of class A is overridden by class B, with its return type, A, matching with the return type of the virtual method of class A being overridden.




Advertisement





• The signature i.e. number and the type of arguments of an overriding method must match with the signature of virtual method being overridden.



//C# Example of method overriding


using System;

//Base class
class Maths
{

//Instance variables
public int num1, num2;


//A method performing addition operation on two integers
//It has two int arguments 
//And, it is declared with virtual keyword
public virtual int MathOperation(int a, int b)	
{
	num1 = a;
	num2 = b;
	return(num1+num2);
}
}


//Maths class is inherited by Subtract class i.e. Derived class
class Subtract:Maths
{

//Instance variables
public int x, y;

//The MathOperation() of base class is overridden to perform subtract operation on two integers.
//It also has two int arguments 
//And, we have used the override modifier with it
public override int MathOperation(int a, int b)	
{
	x = a;
	y = b;
	return (x-y);
}
}

class Override
{
public static void Main(String[] ar)
{
	//Creating and object of derived class, Subtract
	Subtract ob = new Subtract();

	//Calling the overriding method of class Subtract 
	//By using its object
	Console.WriteLine(ob.MathOperation(5,2));
}
}





Output -:




3





Program Analysis



• A class Math is inherited by a class Subtract and the method MathOperation() of class Math 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 arguments of int type, therefore, to successfully override this method in class Subtract, the method MathOperation() in class B also has two arguments of int type.






• The access modifier of an overriding method must match with the access modifier of a virtual method being overridden.



//C# Example of method overriding
//The access modifier of an overriding method must match
//with the access modifier of a virtual method being overridden.


using System;

//Base class
class A
{
//The method ShowName() has "public" access
//It is defined with virtual keyword
public virtual void ShowName()		
{
	Console.WriteLine("A");
}
}


//Derived class
class B:A
{
//The overriding method ShowName() also has a "public" access
public override void ShowName()		
{
	Console.WriteLine("B");
}

public static void Main(String[] ar)
{
	//Creating an object of derived class B
	B ob = new B();
	
	//Calling the overriding method of class B
	//by using its object
	ob.ShowName();
}
}





Output -




B


Class B has inherited class A and it has overridden the inherited ShowName() method of class A. The access modifier of the ShowName()method in the base class A is public, which matches with the access modifier of its overridden version in the derived class B.






Virtual method cannot have a private access


The whole point of marking a method with a virtual keyword of a base class is to allow its definition to be overridden in its derived class.

Therefore, the instance methods of the base class with private access modifier cannot be marked with the virtual access modifier, because the private methods aren't inherited in the first place and therefore, they cannot be overridden by any class.



//C# You cannot use the virtual keyword with a private method
//or even an abstract method, which is meant to be defined by the derived class


using System;

class A					
{

//The ShowMethod() has private access and it cannot be overridden.
//Therefore, the virtual keyword cannot be used with it.
private virtual void ShowMethod()		
{
	Console.WriteLine("A");
}
}




Compile error

A.cs(8,22): error CS0621: 'A.ShowMethod()': virtual or abstract members cannot be private



The private method of a class are never inherited by any class that extends it, therefore, using virtual keyword with them issues a compile error.






Virtual method can have a protected access


The method with protected access modifier can be marked with virtual keyword in a base class, because the protected members of a class are inherited through inheritance, so they can be overridden in its derived class.



//C# You can use the virtual keyword with a protected method


using System;

//Base class
class A
{
//The method ShowName() has "protected" access
//It is defined with virtual keyword
protected virtual void ShowName()		
{
	Console.WriteLine("A");
}
}


//Derived class
class B:A
{
//The overriding method ShowName() also has a "protected" access
protected override void ShowName()		
{
	Console.WriteLine("B");
}

public static void Main(String[] ar)
{
	//Creating an object of derived class B
	B ob = new B();
	
	//Calling the overriding method of class B
	//by using its object
	ob.ShowName();
}
}




Output -




B


The protected method of a base class are inherited by its derived class, therefore, using virtual keyword with protected method is completely fine.

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 the subclass.

Please share this article -

< Prev

Next >

< C# Method Overloading

C# Call By Value >

Advertisement