C# Inheritance and Polymorphism Examples

Understanding C# Inheritance and Polymorphism

Inheritance and polymorphism are fundamental concepts in object-oriented programming (OOP) that allow for code reusability and flexibility. In C#, inheritance enables a class to inherit properties and methods from another class, while polymorphism allows methods to be defined in multiple forms. Below are three diverse examples illustrating these concepts in action.

Example 1: Animal Inheritance

Context

In a zoo management system, you may want to categorize different types of animals. Using inheritance, you can create a base class called Animal and derive specific animal classes like Lion and Elephant.

// Base class
public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal makes a sound");
    }
}

// Derived class
public class Lion : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Roar");
    }
}

// Another derived class
public class Elephant : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Trumpet");
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Animal myLion = new Lion();
        Animal myElephant = new Elephant();

        myLion.Speak(); // Output: Roar
        myElephant.Speak(); // Output: Trumpet
    }
}

Notes

• The Speak method in the base class Animal is marked as virtual, allowing derived classes to override it with their specific implementations.
• This example demonstrates both inheritance (Lion and Elephant inherit from Animal) and polymorphism (calling the Speak method on objects of different derived types).

Example 2: Shape Area Calculation

Context

In a graphical application, you might want to calculate the area of different shapes. Here, you can create a base class Shape and derived classes like Circle and Rectangle. This example shows polymorphism through method overriding.

using System;

// Base class
public abstract class Shape
{
    public abstract double Area();
}

// Derived class for Circle
public class Circle : Shape
{
    private double radius;

    public Circle(double r)
    {
        radius = r;
    }

    public override double Area()
    {
        return Math.PI * radius * radius;
    }
}

// Derived class for Rectangle
public class Rectangle : Shape
{
    private double width;
    private double height;

    public Rectangle(double w, double h)
    {
        width = w;
        height = h;
    }

    public override double Area()
    {
        return width * height;
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Shape myCircle = new Circle(5);
        Shape myRectangle = new Rectangle(4, 6);

        Console.WriteLine("Circle Area: " + myCircle.Area()); // Output: Circle Area: 78.53981633974483
        Console.WriteLine("Rectangle Area: " + myRectangle.Area()); // Output: Rectangle Area: 24
    }
}

Notes

• The Shape class is declared as abstract, which means it cannot be instantiated directly and requires derived classes to implement the Area method.
• This structure allows for easily adding new shapes by simply deriving from Shape and implementing the Area method.

Example 3: Employee Management System

Context

In an employee management system, you might want to manage different types of employees such as Manager and Developer. In this example, we will utilize both inheritance and polymorphism to handle employee details.

using System;

// Base class
public class Employee
{
    public string Name { get; set; }
    public virtual void DisplayInfo()
    {
        Console.WriteLine("Employee: " + Name);
    }
}

// Derived class for Manager
public class Manager : Employee
{
    public int NumberOfReports { get; set; }
    public override void DisplayInfo()
    {
        Console.WriteLine($"Manager: {Name}, Reports: {NumberOfReports}");
    }
}

// Derived class for Developer
public class Developer : Employee
{
    public string ProgrammingLanguage { get; set; }
    public override void DisplayInfo()
    {
        Console.WriteLine($"Developer: {Name}, Language: {ProgrammingLanguage}");
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Employee emp1 = new Manager { Name = "Alice", NumberOfReports = 5 };
        Employee emp2 = new Developer { Name = "Bob", ProgrammingLanguage = "C#" };

        emp1.DisplayInfo(); // Output: Manager: Alice, Reports: 5
        emp2.DisplayInfo(); // Output: Developer: Bob, Language: C#
    }
}

Notes

• The DisplayInfo method is defined in the base class and overridden in each derived class to provide specific information about the employee type.
• This design allows for easy expansion of the system by adding more employee types with their unique properties and methods.

Conclusion

These examples illustrate the power of C# inheritance and polymorphism in creating flexible and maintainable code structures. By reusing code through inheritance and allowing methods to operate on objects of different types through polymorphism, developers can build robust applications with ease.