Inheritance With Different Scenarios In C#

Synopsis

Introduction
Definitions
Advantages of inheritance
Types of inheritance
Reason why it does not support multiple inheritance
Different scenarios with variables
Different scenarios with Methods
Conclusion

Introductions

Inheritance is an important oops concept in programming languages. Without the help of inheritance its difficult to complete any application or project. Inheritance can be used in different scenarios. This article explains how to use inheritance in different ways and in different scenarios.

Definition

Inheritance is acquiring data from one class to another class. Creating a new class from another class is called inheritance.

Advantages of inheritance

Main advantage of inheritance is reusability.

Reusability means that one can use one class propriety or variables and methods can be used from one class to another through inheritance.

In Inheritance, we can use reusability with encapsulation. With the help of access specifiers one can enable encapsulation for variable and method.

Types of inheritance

There are different types of inheritance available.

Single Inheritances.
Multi Level Inheritance.
Multiple Inheritances.
Hierarchy Inheritance.
Hybrid Inheritance.

Reason for why does not support multiple inheritance

Multiple inheritance is not supported in C# as well as it is not supported in Java. Multiple inheritances does not support because of the diamond problem. Diamond problem means let say ‘A’ and ‘B’ are two classes and they have separate methods of the same name.

Two classes inherited to another class “C”. Create object for “C” class and try to access method at that time. While accessing, the compiler will get confused to access the method because the two class methods are of the same name. This is called diamond problem.

Different Scenario with variables

In inheritance, we can use variables with different scenario. Variable can be accessed with the help of access specifiers.

Type 1

public class First
{
public int varA;
}
public class Second : First
{
public int varB;
}
class Program : First
{
static void Main(string[] args)
{
Second obj = new Second();
obj.varA = 10;
obj.varB = 20;
Console.WriteLine("A Value:{0}",obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

A Value:10

B Value:20

Explanation

In Type 1, we have two classes “First” and “Second”. “First” class inherited into “Second” class. After that create an object to “Second” class and access “First” and “second" class variable through the object created. The two classes in the above program show have a public specifier to access class variable, otherwise you cannot access it in the main function using “obj” object.

Type 2

public class First
{
public int varA;
}
public class Second: First
{
public int varB;
}
class Program: First
{
static void Main(string[] args)
{
First obj = new Second();
obj.varA = 10;
obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

This program does not run and displays an error.

Explanation

In Type 2, we have two classes “First” and “Second”. “First” class inherited into “Second” classes, then create an object to “First” class using “Second” class constructor and access only “First” class variable through the created object. Now, you cannot access “Second” class variable using the created object. If you will try to access it, then it will show error.

Type 3

public class First
{
public int varA;
public First()
{
Console.WriteLine("First");
}
}
public class Second: First
{
public int varB;
public Second()
{
Console.WriteLine("Second");
}
}
class Program: First
{
static void Main(string[] args)
{
Second obj = new Second();
obj.varA = 10;
obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

First
Second
A Value:10
B Value:20

Explanation

In Type 3, we have two classes “First” and “Second”. “First” class inherited into the “Second” classes and then create an object to “Second” class and access “First” “Second” class variable through the created object. Creating object to class automatically calls the constructor while allocating memory to the created object. First call base class constructor and after that call derived class constructor.

Type 4

public class First
{
public int varA;
public First()
{
Console.WriteLine("First");
}
}
public class Second: First
{
public int varB;
public Second()
{
Console.WriteLine("Second");
}
}
class Program: First
{
static void Main(string[] args)
{
First obj = new Second();
obj.varA = 10;
//obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
//Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

First
Second
A Value:10

Explanation

In Type 4, we have two classes “First” and “Second”. “First” class inherited into the “Second” class and then create an object to “First” class using “Second” class constructor and access only “First” class variable through the created object. You cannot access “Second” class variable using the created object but two class constructors successfully run because we're creating an object to First class using the Second class constructor.

Type 5

public class First
{
public int varA;
public First()
{
Console.WriteLine("First");
}
}
public class Second: First
{
public int varB;
public Second()
{
Console.WriteLine("Second");
}
}
class Program: First
{
static void Main(string[] args)
{
First obj = new First();
obj.varA = 10;
//obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
//Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

First
A Value:10

Explanation

In Type 5, we have two classes “First” and “Second”. “First” class inherited into the “Second” class, then create an object to “First” class using the “First” class constructor and access only the “First” class variable through the created object. Here run only the first class constructors.

Type 6

public class First
{
public int varA;
public First()
{
Console.WriteLine("First");
}
}
public class Second
{
public int varB;
public Second()
{
Console.WriteLine("Second");
}
}
class Program: First
{
static void Main(string[] args)
{
Second obj = new Second();
//obj.varA = 10;
obj.varB = 20;
//Console.WriteLine("A Value:{0}",obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

Second
B Value:20

Explanation

In Type 6, we have two classes “First” and “Second”. “First” class is not inherited into the “Second” classes. Create object to “Second” class using “Second” class constructor and access only “Second” class variable through the created object because it did not inherit “First” class to “Second” class. Here run “Second class” constructor.

Type 7

public class First
{
public int varA;
public First()
{
Console.WriteLine("First");
}
}
public class Second: First
{
public int varB;
public Second(string varSecond)
{
Console.WriteLine(varSecond);
}
}
class Program: First {
static void Main(string[] args)
{
Second obj = new Second();
obj.varA = 10;
obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

This program does not run and displays an error.

Explanation

In Type 7, we have two classes “First” and “Second”. “First” class inherited into the “Second” class and then create an object to “Second” class using “Second” class constructor. While creating an object to “Second” class it will display an error because class “Second” has a parameter constructor but while creating an object we did not passed not passed a parameter value, so it displays an error. If we pass parameter like the following mentioned snippet, then it would run correctly.

Second obj= new Second(“Second”);

Note:

This type of concept is often asked in an interview.

Type 8

public class First
{
public int varA;
public First(string varFirst)
{
Console.WriteLine(varFirst);
}
}
public class Second: First
{
public int varB;
public Second()
{
Console.WriteLine("Second");
}
}
class Program: First
{
static void Main(string[] args)
{
Second obj = new Second();
obj.varA = 10;
obj.varB = 20;
Console.WriteLine("A Value:{0}", obj.varA);
Console.WriteLine("B Value:{0}", obj.varB);
Console.Read();
}
}

Sample Output

This program does not run and displays an error.

Explanation

In Type 8, we have two classes “First” and “Second”. “First” class inherited into the “Second” class. After that create object to “Second” class using “Second” class constructor. While creating an object to “Second” class, error comes because class “First” has a parameter constructor but while creating an object we did not passed a parameter value, so it displays and error in the “Second” class constructor: “First does not contains a constructor that takes 0 arguments ”.

The following will display error: “First does not contains a constructor that takes 0 arguments ” and “Second does not contains a constructor that takes 1 arguments ”.

Second obj= new Second("Second");

Can avoid error if constructor use same base and derived class signature.

Note:

This type of concept is often asked in interviews.

Conclusions

Above mentioned scenarios are generally asked in interviews. Inheritance helps in learning different scenarios with constructors and access modifiers.

19 Comments

Join the conversation! Your thoughts help the community grow.

Shobana J10y ago
Nice explanation
- Vignesh Mani10y ago
  Thank You
Yuva V11y ago
thank you
Mahsa Hassankashi11y ago
Thanks for sharing
- Vignesh Mani11y ago
  Thank You
Vignesh Mani11y ago
Thank You
Rojalin Sahoo11y ago
Nice one. Very nicely explained
Pankaj Kumar Choudhary11y ago
this one of the best explanation about inheritance ever i see...... Thanks for share......
- Vignesh Mani11y ago
  Thank You
Santhakumar Munuswamy11y ago
Good work. Thanks for sharing Vignesh
- Vignesh Mani11y ago
  Thank You
Mohammed Ibrahim11y ago
nice share
Vignesh Mani11y ago
Thank You To all
Prem Anandh J11y ago
Nice one..
Ratnesh Singh11y ago
good collection...
Rakesh11y ago
Good explain
Ankit Bansal11y ago
thanks for sharing..
Karthikeyan K11y ago
Good one sir...Thanks for sharing
Rajeesh Menoth11y ago
Nice Share..