Polymorphism

Introduction to Polymorphism

Polymorphism is a fundamental concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common base class. It enables flexibility and extensibility in software design.

Key Concepts

• Polymorphism: The ability of different classes to be treated as instances of the same class through inheritance.
• Method Overriding: Allows a subclass to provide a specific implementation of a method that is already defined in its superclass.
• Compile-time Polymorphism: Also known as method overloading, where multiple methods with the same name but different parameters are defined in a class.
• Runtime Polymorphism: Achieved through method overriding, where the method to be invoked is determined at runtime based on the type of object.

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

// Derived class
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

// Another derived class
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows");
    }
}

// Usage
Animal myAnimal = new Dog(); // Upcasting
myAnimal.MakeSound(); // Output: Dog barks

myAnimal = new Cat(); // Upcasting
myAnimal.MakeSound(); // Output: Cat meows
            

Method Overloading

Method overloading allows multiple methods with the same name but different parameters to be defined in a class.

public class Calculator
{
    public int Add(int num1, int num2)
    {
        return num1 + num2;
    }

    public double Add(double num1, double num2)
    {
        return num1 + num2;
    }
}

// Usage
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(3, 5)); // Output: 8 (int version)
Console.WriteLine(calc.Add(2.5, 3.5)); // Output: 6.0 (double version)
            

Conclusion

Polymorphism is a powerful concept in .NET that enhances code reusability and flexibility. Understanding polymorphism allows developers to design robust and extensible software systems.