Overview

Polymorphism, a core concept in Object-Oriented Programming (OOP), enables objects of different classes to be treated as objects of a common super class. It's a mechanism where a single interface can be used to represent different underlying forms (data types). By implementing polymorphic behavior in designs, developers achieve flexibility and extensibility in their applications, allowing for easy maintenance and future enhancements.

Key Concepts

1. Dynamic Polymorphism (Method Overriding): Achieved through inheritance, allowing a subclass to provide a specific implementation of a method that is already provided by one of its superclasses.
2. Static Polymorphism (Method Overloading): Allows multiple methods in the same class to have the same name but different parameters.
3. Interface Polymorphism: Utilizing interfaces to achieve polymorphism, enabling a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world.

Common Interview Questions

Basic Level

1. What is polymorphism and why is it important in OOP?
2. Give an example of method overloading in C#.

Intermediate Level

3. How does method overriding differ from method overloading?

Advanced Level

4. Can you explain the use of polymorphism in a design pattern, such as the Strategy Pattern?

Detailed Answers

1. What is polymorphism and why is it important in OOP?

Answer: Polymorphism, derived from Greek meaning "many forms," is a feature of OOP that allows objects of different types to be treated as objects of a common supertype. It is important because it enables a single interface to be used for a general class of actions, which makes the software easier to extend and maintain. It enhances the flexibility and interoperability of the code.

Key Points:
- Enhances code reusability
- Improves code maintainability
- Increases system extensibility

Example:

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

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

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

2. Give an example of method overloading in C#.

Answer: Method overloading, a form of static polymorphism, allows a class to have multiple methods with the same name but with different parameters. It enables the methods to perform similar but slightly different functions.

Key Points:
- Same method name, different parameters
- Compile-time polymorphism
- Increases code readability

Example:

public class Calculator
{
    // Method to add two integers
    public int Add(int a, int b)
    {
        return a + b;
    }

    // Overloaded method to add three integers
    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

3. How does method overriding differ from method overloading?

Answer: Method overriding and method overloading are both forms of polymorphism but differ in key ways. Method overriding, a dynamic polymorphism form, involves redefining a method in a subclass that is already defined in its superclass. Method overloading, on the other hand, is a form of static polymorphism that allows a class to have multiple methods with the same name but different parameter lists.

Key Points:
- Method overriding is about using the same method name and parameters but different implementations in subclasses.
- Method overloading is about having the same method name with different signatures (parameter lists) within the same class.
- Method overriding is a runtime concept, while method overloading is a compile-time concept.

Example:

// Method Overriding
public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Base class display");
    }
}

public class DerivedClass : BaseClass
{
    public override void Display()
    {
        Console.WriteLine("Derived class display");
    }
}

// Method Overloading
public class ExampleClass
{
    public void Display(string a)
    {
        Console.WriteLine($"Displaying: {a}");
    }

    public void Display(int a)
    {
        Console.WriteLine($"Displaying: {a}");
    }
}

4. Can you explain the use of polymorphism in a design pattern, such as the Strategy Pattern?

Answer: The Strategy Pattern is a behavioral design pattern that enables selecting an algorithm's runtime. It makes use of polymorphism by defining a family of algorithms, encapsulating each one, and making them interchangeable. Polymorphism allows these algorithms to be swapped out easily at runtime.

Key Points:
- Promotes the "program to interfaces, not implementations" principle.
- Enhances flexibility by allowing the behavior of a class to be extended easily without modifying its code.
- Facilitates the dynamic swapping of algorithms or behaviors.

Example:

public interface ISortStrategy
{
    void Sort(List<int> list);
}

public class QuickSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("QuickSort algorithm");
        // Implementation
    }
}

public class MergeSort : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("MergeSort algorithm");
        // Implementation
    }
}

public class SortedList
{
    private List<int> _list = new List<int>();
    private ISortStrategy _sortstrategy;

    public void SetSortStrategy(ISortStrategy sortstrategy)
    {
        this._sortstrategy = sortstrategy;
    }

    public void Add(int number)
    {
        _list.Add(number);
    }

    public void Sort()
    {
        _sortstrategy.Sort(_list);
        // Output sorted list
    }
}

This example demonstrates how the Strategy Pattern utilizes polymorphism to switch between different sorting algorithms at runtime, showcasing flexibility and extensibility in design.