Polymorphism in C#

# CHAPTER 16

Polymorphism in C# #

1. Introduction #

2. Learning Objectives #

• Define Polymorphism in OOP.

• Understand Compile-time Polymorphism (Method Overloading).

• Understand Runtime Polymorphism (Method Overriding).

• Use Base class variables to hold Derived class objects.

3. Types of Polymorphism #

1. 1. Compile-time Polymorphism (Static Binding): Achieved through Method Overloading. The compiler knows exactly which method to call when it builds the application.

1. 2. Runtime Polymorphism (Dynamic Binding): Achieved through Inheritance and Method Overriding (virtual/override). The application decides which method to call *while it is running* based on the actual object type.

4. Compile-time Polymorphism (Recap) #

class Printer
{
    public void Print(int i) { Console.WriteLine($"Printing int: {i}"); }
    public void Print(string s) { Console.WriteLine($"Printing string: {s}"); }
}
// The compiler knows which one to call at compile time based on the argument.

5. Runtime Polymorphism (The Real Magic) #

using System;
using System.Collections.Generic;

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

class Dog : Animal
{
    public override void Speak() { Console.WriteLine("Woof!"); }
}

class Cat : Animal
{
    public override void Speak() { Console.WriteLine("Meow!"); }
}

class Program
{
    static void Main()
    {
        // A Base class variable pointing to a Derived object!
        Animal myPet = new Dog();
        
        // Output: "Woof!"
        // The CLR checks at runtime what myPet *actually* is, and calls Dog's method.
        myPet.Speak(); 
        
        // Let's create an array of Base class objects
        List<Animal> zoo = new List<Animal>();
        zoo.Add(new Dog());
        zoo.Add(new Cat());
        zoo.Add(new Animal());

        // We can treat them all identically!
        foreach (Animal a in zoo)
        {
            a.Speak(); // Output: Woof!, Meow!, Animal sound
        }
    }
}

6. Why is this useful? #

With polymorphism, you just put them all in a List<Shape> and loop through them calling shape.Draw(). If you add a Hexagon class later, you don't have to change the loop code at all! The system automatically scales.

7. OOP and Memory Explanation #

8. Common Mistakes #

• Forgetting override: If you forget the override keyword in the child class (and optionally use new), you perform Method Hiding. In this case, Animal myPet = new Dog(); myPet.Speak(); will output "Animal sound", entirely defeating runtime polymorphism! Always use override.

9. Best Practices #

• Use polymorphism to eliminate massive if/else and switch statements that check an object's type.

10. Exercises #

1. 1. Create a Vehicle base class with a virtual StartEngine() method.

1. 2. Create Car and Motorcycle derived classes that override StartEngine().

1. 3. In Main(), create an array of Vehicle containing both cars and motorcycles, and loop through them calling StartEngine().

11. MCQs with Answers #

Q5. Can a variable of type DerivedClass hold an object of type BaseClass? a) Yes b) No (e.g., Dog d = new Animal(); is invalid) Answer: b) No

12. Interview Questions #

• Q: Differentiate between Compile-time and Runtime Polymorphism. Give examples of each.

• Q: Explain the "Liskov Substitution Principle" (The 'L' in SOLID) in the context of Polymorphism. (Answer: Objects of a superclass shall be replaceable with objects of its subclasses without breaking the application).

13. Summary #

14. Next Chapter Recommendation #