C# Inheritance & Overloading

C# Inheritance

In C#, inheritance allows us to create a new class from an existing class. It is a key feature of Object-Oriented Programming (OOP).

The class from which a new class is created is known as the base class (parent or superclass). And the new class is called derived class (child or subclass)

The derived class inherits the fields and methods of the base class. This helps with the code reusability in C#.

How to perform inheritance in C#?

In C#, we use the : symbol to perform inheritance. For example,

class Animal {  
  // fields and methods
} 

// Dog inherits from Animal
class Dog : Animal {
  // fields and methods of Animal 
  // fields and methods of Dog 
}

Here, we are inheriting the derived class Dog from the base class Animal. The Dog class can now access the fields and methods of Animal class.

Example: C# Inheritance

using System;

class Program
{
    static void Main(string[] args)
    {
        // object of derived class
        Dog labrador = new Dog();

        // access field and method of base class
        labrador.name = "Rohu";
        labrador.DisplayInfo();

        //child's own method
        labrador.ShowName();
        Console.ReadLine();
    }
}

// base class
class Animal
{
    public string name;

    public void DisplayInfo()
    {
        Console.WriteLine("I am an animal");
    }
}

//derived class
class Dog: Animal
{
    public void ShowName()
    {
        Console.WriteLine("My name is " + name);
    }
}

Here, we are using labrador (object of Dog) to access the name and display() of the Animal class. This is possible because the derived class inherits all fields and methods of the base class.

Also, we have accessed the name field inside the method of the Dog class.

is-a relationship

In C#, inheritance is an is-a relationship. We use inheritance only if there is an is-a relationship between two classes. For example,

Dog is an Animal
Apple is a Fruit
Car is a Vehicle

We can derive Dog from Animal class. Similarly, Apple from Fruit class and Car from Vehicle class.

Protected Members in C# Inheritance

When we declare a field or method as protected, it can only be accessed from the class and its derived classes.

Example: protected Members in Inheritance

using System;
class Program
{
    static void Main(string[] args)
    {
        Dog labrador = new Dog();

        // wrong - cannot access protected method from outside child class
        labrador.eat();

        Console.ReadLine();
    }
}
// base class
class Animal
{
    protected void eat()
    {
        Console.WriteLine("I can eat...");
    }
}

class Dog : Animal
{

}

In the above example, we have created a class named Animal. The class includes a protected method eat().

We have derived the Dog class from the Animal class.

Notice the statement labrador.eat();

Types of inheritance

There are the following types of inheritance:

1.Single Inheritance

In single inheritance, a single derived class inherits from a single base class.

2.Multilevel Inheritance

In multilevel inheritance, a derived class inherits from a base and then the same derived class acts as a base class for another class.

3.Hierarchical Inheritance

In hierarchical inheritance, multiple derived classes inherit from a single base class.

4.Multiple Inheritance (not supported)

In multiple inheritance, a single derived class inherits from multiple base classes. C# doesn't support multiple inheritance. However, we can achieve multiple inheritance through interfaces.

5.Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. The combination of multilevel and hierarchical inheritance is an example of Hybrid inheritance.

Method Overriding in C# Inheritance

If the same method is present in both the base class and the derived class, the method in the derived class overrides the method in the base class. This is called method overriding in C#. For example,

using System;

// base class
class Animal
{
    public virtual void eat()
    {
        Console.WriteLine("I eat food");
    }
}
// derived class of Animal 
class Dog : Animal
{
    // overriding method from Animal
    public override void eat()
    {
        Console.WriteLine("I eat Dog food");
    }
}
class Program
{
    static void Main(string[] args)
    {
        // object of derived class
        Dog labrador = new Dog();

        // accesses overridden method
        labrador.eat();
    }
}

In the above example, the eat() method is present in both the base class and derived class.

When we call eat() using the Dog object labrador,

labrador.eat(); the method inside Dog is called. This is because the method inside Dog overrides the same method inside Animal.

Notice, we have used virtual and override with methods of the base class and derived class respectively. Here,

virtual - allows the method to be overridden by the derived class
override - indicates the method is overriding the method from the base class

`base` Keyword in C# Inheritance

In the previous example, we saw that the method in the derived class overrides the method in the base class.

However, what if we want to call the method of the base class as well?

In that case, we use the base keyword to call the method of the base class from the derived class.

using System;

// base class
class Animal
{
    public virtual void eat()
    {
        Console.WriteLine("I eat food");
    }
}
// derived class of Animal 
class Dog : Animal
{
    // overriding method from Animal
    public override void eat()
    {
        // call method from Animal class
        base.eat();
        Console.WriteLine("I eat Dog food");
    }
}
class Program
{
    static void Main(string[] args)
    {
        // object of derived class
        Dog labrador = new Dog();

        // accesses overridden method
        labrador.eat();
    }
}