Overview

In Object-Oriented Programming Systems (OOPS), inheritance hierarchies refer to the mechanism by which one class (subclass or derived class) can inherit properties and methods from another class (superclass or base class). This concept is crucial for code reusability, extensibility, and maintainability. Ensuring well-structured and maintainable inheritance hierarchies involves adhering to principles like Liskov Substitution, avoiding deep inheritance trees, and favoring composition over inheritance where appropriate.

Key Concepts

1. Single Inheritance vs. Multiple Inheritance: Understanding the differences and implications of inheriting from one vs. multiple classes.
2. Polymorphism and Overriding: How derived classes can override or extend the functionality of base class methods.
3. Interface Segregation and Abstract Classes: Differentiating between interfaces, abstract classes, and when to use them to enforce certain behaviors in derived classes.

Common Interview Questions

Basic Level

1. What is inheritance and how do you use it in C#?
2. Provide an example of a simple inheritance hierarchy in C#.

Intermediate Level

3. How does polymorphism work with inheritance in C#?

Advanced Level

4. Describe how you would refactor a deep inheritance hierarchy to improve maintainability.

Detailed Answers

1. What is inheritance and how do you use it in C#?

Answer: Inheritance is a fundamental concept of OOPS that allows a class to inherit fields and methods from another class. In C#, you use the : symbol to denote inheritance. The base class provides common functionality to derived classes, which can extend or modify this functionality. Inheritance promotes code reuse and can simplify complex systems.

Key Points:
- Base and derived classes.
- Code reuse.
- virtual and override keywords for method overriding.

Example:

public class Animal
{
    public void Eat()
    {
        Console.WriteLine("Eating...");
    }
}

public class Dog : Animal // Dog inherits from Animal
{
    public void Bark()
    {
        Console.WriteLine("Barking...");
    }
}

// Usage
Dog myDog = new Dog();
myDog.Eat(); // Inherited from Animal
myDog.Bark(); // Defined in Dog

2. Provide an example of a simple inheritance hierarchy in C#.

Answer: A simple inheritance hierarchy involves base and derived classes where derived classes inherit properties and methods from the base class. This hierarchy can represent real-world relationships, such as a general class Vehicle and more specific classes like Car and Bicycle.

Key Points:
- Demonstrates code reuse.
- Showcases basic inheritance principles.
- Highlights the base keyword for base class access.

Example:

public class Vehicle
{
    public string LicensePlate { get; set; }

    public void Start()
    {
        Console.WriteLine("Vehicle started.");
    }
}

public class Car : Vehicle
{
    public int NumberOfDoors { get; set; }

    public void LockDoors()
    {
        Console.WriteLine("Doors locked.");
    }
}

public class Bicycle : Vehicle
{
    public bool HasBasket { get; set; }

    // Overriding the Start method
    public new void Start()
    {
        Console.WriteLine("Bicycle pedal started.");
    }
}

// Usage
Car myCar = new Car();
myCar.Start(); // Inherited from Vehicle
myCar.LockDoors(); // Defined in Car

Bicycle myBicycle = new Bicycle();
myBicycle.Start(); // Overridden in Bicycle

3. How does polymorphism work with inheritance in C#?

Answer: Polymorphism in C# allows derived classes to provide their own implementation of methods defined in their base class. This is achieved through method overriding, where a derived class method uses the override keyword, and the base class method is marked with virtual or abstract. Polymorphism enables objects of different classes to be treated as objects of a common superclass.

Key Points:
- Method overriding.
- virtual, abstract, and override keywords.
- Base class reference to derived class objects.

Example:

public abstract class Shape
{
    public abstract void Draw(); // Abstract method
}

public class Circle : Shape
{
    public override void Draw() // Overriding Draw for Circle
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Square : Shape
{
    public override void Draw() // Overriding Draw for Square
    {
        Console.WriteLine("Drawing a square.");
    }
}

// Polymorphism in action
List<Shape> shapes = new List<Shape> { new Circle(), new Square() };
foreach (var shape in shapes)
{
    shape.Draw(); // Calls the respective Draw method
}

4. Describe how you would refactor a deep inheritance hierarchy to improve maintainability.

Answer: Refactoring a deep inheritance hierarchy involves reducing complexity and improving flexibility by favoring composition over inheritance, using interfaces, and applying design patterns like Strategy or State for behavior variation.

Key Points:
- Favor composition over inheritance.
- Use interfaces for behavior specification.
- Apply design patterns to manage behavior changes.

Example:

// Before: Deep inheritance hierarchy
public class BaseEmployee { /* Common fields and methods */ }
public class Manager : BaseEmployee { /* Additional fields and methods */ }
public class DepartmentHead : Manager { /* More specific fields and methods */ }

// After: Refactoring with composition
public interface IWork
{
    void PerformWork();
}

public class ManagerWork : IWork
{
    public void PerformWork()
    {
        Console.WriteLine("Managing work.");
    }
}

public class Employee
{
    public IWork WorkBehavior { get; set; }

    public void PerformWork()
    {
        WorkBehavior.PerformWork();
    }
}

// Usage
Employee manager = new Employee { WorkBehavior = new ManagerWork() };
manager.PerformWork(); // Outputs: Managing work.

This approach reduces the rigidity and fragility of a deep inheritance hierarchy by encapsulating variable behaviors in separate classes and using interfaces for flexible behavior assignment.