Overview

Method overloading and method overriding are fundamental concepts in object-oriented programming (OOP) that allow programmers to design flexible and scalable systems. Method overloading enables a class to have multiple methods with the same name but different parameters. Method overriding, on the other hand, allows a subclass to provide a specific implementation of a method that is already defined in its superclass. Understanding these concepts is crucial for leveraging polymorphism and designing robust OOP systems.

Key Concepts

1. Polymorphism: Enables objects of different classes to be treated as objects of a common superclass.
2. Compile-Time Polymorphism: Achieved through method overloading.
3. Runtime Polymorphism: Achieved through method overriding.

Common Interview Questions

Basic Level

1. What is method overloading and how does it differ from method overriding?
2. Provide an example of method overloading in C#.

Intermediate Level

3. Explain the rules for method overriding in C#.

Advanced Level

4. How do you use method overloading and overriding to implement polymorphism? Provide a design example.

Detailed Answers

1. What is method overloading and how does it differ from method overriding?

Answer: Method overloading is a feature that allows a class to have more than one method with the same name, as long as their parameter lists are different. It's a compile-time concept. Method overriding, in contrast, occurs when a subclass or derived class has a method with the same name, return type, and parameters as in its base class. It's a runtime concept, enabling dynamic method dispatch.

Key Points:
- Method overloading is resolved at compile-time.
- Method overriding is resolved at runtime.
- Overloading improves code readability, while overriding supports runtime polymorphism.

Example:

public class Calculator
{
    // Method overloading
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }
}

public class BaseClass
{
    public virtual void Display()
    {
        Console.WriteLine("Display from Base Class");
    }
}

public class DerivedClass : BaseClass
{
    // Method overriding
    public override void Display()
    {
        Console.WriteLine("Display from Derived Class");
    }
}

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

Answer: Method overloading enables a class to offer multiple methods with the same name but with different parameter lists. This can be useful for creating more intuitive and flexible APIs.

Key Points:
- Overloaded methods must differ in the number or type of their parameters.
- They can have different return types if their parameters differ.
- Method overloading is decided at compile time.

Example:

public class Shape
{
    // First overload
    public void Draw(int length, int breadth)
    {
        Console.WriteLine($"Drawing Rectangle with Length: {length}, Breadth: {breadth}");
    }

    // Second overload
    public void Draw(int side)
    {
        Console.WriteLine($"Drawing Square with Side: {side}");
    }
}

3. Explain the rules for method overriding in C#.

Answer: Method overriding allows a subclass to provide a specific implementation of a method that is already provided by its base class or interface. The overriding method must have the same name, return type, and parameters as the method in the base class and is used to implement runtime polymorphism.

Key Points:
- The method must be marked with the virtual keyword in the base class and override in the derived class.
- The access modifier of the overriding method must be the same as the overridden method.
- Properties and indexers can also be overridden.

Example:

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

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

4. How do you use method overloading and overriding to implement polymorphism? Provide a design example.

Answer: Polymorphism is a core OOP concept that allows objects of different classes to be treated as objects of a common superclass. Method overloading and overriding are two mechanisms that support polymorphism by allowing methods to either perform different operations based on their inputs (overloading) or provide specific implementations in derived classes (overriding).

Key Points:
- Method overloading enables compile-time (static) polymorphism.
- Method overriding enables runtime (dynamic) polymorphism.
- Together, they provide the flexibility to design scalable and maintainable code.

Example:

public class Printer
{
    // Method overloading within the same class
    public void Print(string content)
    {
        Console.WriteLine($"Printing string: {content}");
    }

    public void Print(int content)
    {
        Console.WriteLine($"Printing integer: {content}");
    }
}

public class DocumentPrinter : Printer
{
    // Method overriding for runtime polymorphism
    public override void Print(string content)
    {
        // Custom implementation for DocumentPrinter
        Console.WriteLine($"Document printing: {content}");
    }
}

This example showcases how method overloading and overriding can be used to provide both compile-time and runtime polymorphism, enabling different behaviors for the Print method based on the context (type of input or instance).