Advertisement

---

Top

< Prev

Next >

One of the main features of an object-oriented language like C# is its feature of inheritance, using which we can create a class by inheriting the features of an existing class and also adding some unique features specific to the class being created.

The class that wants to inherit the feature of an existing class is called the derived class, whereas, the class whose features are to be inherited is referred to as the base class. Hence, the feature of inheritance gives C#, the power of reusability.

What features of a class are inherited through inheritance?

When a class inherits an existing class, it inherits only the members of the existing class that are marked with public and protected access modifiers. These inherited members of the superclass are instance variables, method, properties, etc.

Note- Members marked with private access modifiers of the existing class are never inherited.






Syntax of Inheritance


Let us take a look at a general syntax of performing inheritance, using which we could define a derived class which is inheriting a base class.



class derived-class-name : base-class-name
{
//members of derived class
}



• In the syntax, The derived-class-name is the name of the derived class, which is being created and it is going to inherit features of another class i.e. a base class with the name base-class-name.


• The colon : between derived-class-name and base-class-name indicates that inheritance is being performed.









A simple example of inheritance




//C# Example of Inheritance

using System;

class A
{
//An instance variable with public access
public int a = 10;
	
//An instance variable with protected access 	
protected int b = 20;		

//A method with public access
public void GetName()		
{
	Console.WriteLine("A");
}
}


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

	//Accessing the inherited instance variable, a
	//by using the object of B class
	Console.WriteLine(ob.a);

	//Accessing the inherited instance variable, b
	//by using the object of B class
	Console.WriteLine(ob.b);
}
}





Output is :




A
10
20





Program Analysis


In this code, we have created a class B, by inheriting a class A, thereby class B has inherited the following members of class A:
• instance variable, a, of class A, having public access.
• instance variable, b, of class A, having protected access.
• method, GetName() of class A, having public access.
Hence, the reference variable of class B has directly accessed the instance variable, a, b and the method GetName(), because post-inheritance these features of class A are also a part of class B.






A subclass cannot inherit a private member of its superclass.


Only the members declared with public and private access modifiers are inherited. The members declared with private access modifiers are never inherited.



//C# Private member are never inherited

using System;

class A
{
//Instance variable with private access
private int a = 10;	

//A method with private access
private void GetName()	
{
	Console.WriteLine("A");
}
}

// Class B inheriting class A
class B:A 
{
public static void Main(String[] ar)
{
	//Creating an object of class B 
	B ob= new B();

	//Calling the not-inherited GetName() method
	//by using the object of B class
	//This will issue a compile error
	ob.GetName();

	//Accessing the not-inherited instance variable, a
	//by using the object of B class
	//This will also issue a compile error
	Console.WriteLine(ob.a);
}
}





Output -:




A.cs(28,5): error CS0122: 'A.GetName()' is inaccessible due to its protection level
A.cs(33,23): error CS0122: 'A.a' is inaccessible due to its protection level





Program Analysis



• The instance variable, a and the method GetName() of class A are marked with the private access modifier. Hence, they will not be inherited by the class B, and, trying to access them using reference of class B gives compile errors.


• There is no compile error if a class tries to inherit another class, which has private members but the compile error is only thrown when we try to access private members of superclass using reference of subclass(because these private members of superclass were never inherited by its subclass).





Advertisement






Types of inheritance :



• Single level inheritance
• Multi level inheritance
• Multiple inheritance







Single Level Inheritance


When a class inherits another class, such type of inheritance is known as single level inheritance.



//C# Example of single level inheritance i.e. when one class inherits another class 

using System;

class A
{
public void ShowA()
{
	Console.WriteLine("A");
}
}

//class B inheriting features of class A
class B:A		
{
public void ShowB()
{
	Console.WriteLine("B");
}

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

	//Calling the method of class B
	//by using the object of class B
	ob.ShowB();
}
}


Class B has inherited class A and thereby, the class B has access to the method ShowA() of class A, just as it can access its own method ShowB() i.e. by using its object with a dot operator and with the name of the method.






Multilevel Inheritance


When a class inherits another class, which has itself inherited another class, such type of inheritance is known as multi-level inheritance.



//C# Example of Multi-level inheritance

using System;

class A
{
public void ShowA()
{
	Console.WriteLine("A");
}
}


//class B inheriting the features of class A
class B:A 		
{
public void ShowB()
{
	Console.WriteLine("B");
}
}


//class C inheriting the features of class B
class C:B		
{
public void ShowC()
{
	Console.WriteLine("C");
}

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


	//Using the object of class C
	//to access the inherited method of class A
	ob.ShowA();


	//Using the object of class C
	//to access the inherited method of class B
	ob.ShowB();

	//Using the object of class C
	//to access method of its own class
	ob.ShowC();
}
}

Output:

A
B
C


Class C has inherited class B, which has itself inherited class A. This gives class C a direct access to the methods ShowA() and ShowB() method of class A and B, therefore, we have directly accessed them with an object of class C.






Multiple inheritance is not allowed in C#


In C#, a class cannot inherit multiple classes at the same time, at once. Doing so, gives a compile error.



//C# A direct multiple inheritance is not allowed 
//which means, you cannot inherit multiple classes, all at once.

using System;

class A
{
public void ShowA()
{
	Console.WriteLine("A");
}
}


//class B
class B 		
{
public void ShowB()
{
	Console.WriteLine("B");
}
}


//class C tring to inherit the features of class A and B at once
//This will issue a compile error
class C:B,A		
{
public void ShowC()
{
	Console.WriteLine("C");
}
}





Compile Error:




A.cs(27,11): error CS1721: Class 'C' cannot have multiple base classes: 'B' and 'A'


The compile error states that class C cannot have multiple base classes i.e. it cannot inherit multiple classes at the same time, at once.






Why inheritance is used?



• Inheritance is used to use the existing features of a class.
• Inheritance is also used in a situation when we want to create a more specialized version of a generic(general) class, by combining some specialized features with the inherited general features of a general class.

Let's understand this by an example. We are creating a specialized class, Mango, by adding some specialized methods of Mango and by inheriting some general features of the class, Fruit.



//C# Example of creating a specialized class by inheriting general class


using System;

//A general class, Fruit
class Fruit
{
public void ShowFruit()
{
	Console.WriteLine("This is a fruit");
}
}


//A specialized class, Mango, which is inheriting class Fruit
class Mango:Fruit		
{
public void FruitColor()
{
	Console.WriteLine("Color - Yellow");
}

public void FruitName()
{
	Console.WriteLine("Name - Mango");
}

public void HasSeed()
{
	Console.WriteLine("Seed - Yes");
}
}


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

	//Accessing the inherited "general" method ShowFruit() of Fruit class
	//by using the object of Mango class
	ob.ShowFruit();

	//Using the object of Mango class
	//To call its specialized methods
	ob.FruitName();
	ob.FruitColor();
	ob.HasSeed();
}
}





Output -:




This is a fruit
Name - Mango
Color - Yellow
Seed - Yes





Program Analysis

• In this code, we have created a specialized class Mango by inheriting a generic(general) class Fruit.
• Hence, the class Mango has inherited the general method ShowFruit() of the class Fruit, and have also added its own unique specialized methods to display properties of a Mango.







Inheritance also promotes -:



• Code reuse.
• Polymorphism (we will discuss it in the next article).





Please share this article -






< Prev
Next >
< C# Polymorphism
C# Constructors >



Advertisement