What are the different types of inheritance?

Inheritance in object-oriented programming comes in different forms, each with its own characteristics. Here are the main types of inheritance:

Single Inheritance:
In single inheritance, a class can inherit from only one base class. This is the simplest form of inheritance where a derived class extends a single parent class.

using System;

// Base class
class Vehicle
{
    public void Start()
    {
        Console.WriteLine("Vehicle starting...");
    }
}

// Derived class inheriting from Vehicle
class Car : Vehicle
{
    public void Drive()
    {
        Console.WriteLine("Car is driving...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car myCar = new Car();
        myCar.Start();  // Access method from base class
        myCar.Drive();  // Access method from derived class
    }
}

Multiple Inheritance (through Interfaces):
Multiple inheritance allows a class to inherit from more than one base class. However, many programming languages, including C#, Java, and C++, do not support multiple inheritance directly due to potential complexities and ambiguities it can introduce. Instead, they allow multiple inheritance through interfaces or abstract classes.

using System;

// Interfaces
interface IDrivable
{
    void Drive();
}

interface IFlyable
{
    void Fly();
}

// Class implementing multiple interfaces
class FlyingCar : IDrivable, IFlyable
{
    public void Drive()
    {
        Console.WriteLine("Flying car is driving...");
    }

    public void Fly()
    {
        Console.WriteLine("Flying car is flying...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        FlyingCar myFlyingCar = new FlyingCar();
        myFlyingCar.Drive();
        myFlyingCar.Fly();
    }
}

Multilevel Inheritance:
In multilevel inheritance, a derived class is used as the base class for another class. It forms a chain of inheritance where one class inherits from another, which in turn can be inherited by another class.

using System;

// Base class
class Animal
{
    public void Eat()
    {
        Console.WriteLine("Animal is eating...");
    }
}

// Derived class
class Mammal : Animal
{
    public void Run()
    {
        Console.WriteLine("Mammal is running...");
    }
}

// Further derived class
class Dog : Mammal
{
    public void Bark()
    {
        Console.WriteLine("Dog is barking...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dog myDog = new Dog();
        myDog.Eat();  // Access method from base class
        myDog.Run();  // Access method from derived class
        myDog.Bark(); // Access method from further derived class
    }
}

Hierarchical Inheritance:
Hierarchical inheritance involves multiple classes inheriting from a single base class. All the derived classes share a common parent class.

using System;

// Base class
class Shape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a shape...");
    }
}

// Derived classes
class Circle : Shape
{
    public void DrawCircle()
    {
        Console.WriteLine("Drawing a circle...");
    }
}

class Rectangle : Shape
{
    public void DrawRectangle()
    {
        Console.WriteLine("Drawing a rectangle...");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Circle myCircle = new Circle();
        myCircle.Draw();       // Access method from base class
        myCircle.DrawCircle(); // Access method from derived class

        Rectangle myRectangle = new Rectangle();
        myRectangle.Draw();        // Access method from base class
        myRectangle.DrawRectangle(); // Access method from another derived class
    }
}

Hybrid Inheritance:
Hybrid inheritance is a combination of different types of inheritance, such as single, multiple (via interfaces), and multilevel. It's less common and can lead to complex class relationships.

Multiple Inheritance (not directly supported):
In languages that don't support multiple inheritance directly, like C# and Java, multiple inheritance can be simulated through interfaces. A class can implement multiple interfaces, allowing it to inherit behavior from multiple sources without the complications of multiple inheritance.

Cyclic Inheritance (not recommended):
Cyclic inheritance occurs when classes form a circular relationship in their inheritance hierarchy. This is usually a design flaw and should be avoided as it can lead to confusion and issues in the code.

Different programming languages have different approaches and support for these types of inheritance. The choice of inheritance type depends on the design goals, complexity of the problem, and the features provided by the programming language being used.