Overview

In object-oriented programming (OOP), both composition and inheritance are fundamental concepts used to define relationships between classes. Understanding the difference between composition and inheritance, and knowing when to use each, is crucial for designing flexible, maintainable, and scalable software systems. Inheritance allows a class to inherit properties and methods from another class, promoting code reuse. Composition, on the other hand, involves building classes that contain instances of other classes, emphasizing a has-a relationship over the is-a relationship of inheritance. The choice between composition and inheritance can greatly affect the design and complexity of your software.

Key Concepts

1. Inheritance: It’s a mechanism where a new class (derived class) inherits the features from an existing class (base class). It supports code reusability and is used to achieve polymorphism.
2. Composition: It’s a design principle where a class is composed of one or more objects of other classes, suggesting a has-a relationship rather than is-a.
3. Design Principles: Understanding when to use composition over inheritance is key to applying the SOLID design principles, particularly the Liskov Substitution Principle (LSP) and the Dependency Inversion Principle (DIP).

Common Interview Questions

Basic Level

1. Explain the concept of inheritance and composition in OOP.
2. Can you demonstrate a simple example of composition in C#?

Intermediate Level

3. How does composition solve the problem of multiple inheritance in C#?

Advanced Level

4. Discuss the impact of using composition over inheritance in terms of software design patterns and principles.

Detailed Answers

1. Explain the concept of inheritance and composition in OOP.

Answer: Inheritance and composition are two major concepts in OOP that describe different types of relationships between classes. Inheritance is a relationship where a class (derived class) extends another class (base class), inheriting its properties and methods. This promotes code reuse and supports polymorphism. Composition, on the other hand, is a design principle where a class is composed of one or more instances of other classes, indicating a has-a relationship.

Key Points:
- Inheritance implies an is-a relationship (e.g., a Dog is an Animal).
- Composition implies a has-a relationship (e.g., a Car has an Engine).
- Inheritance is hierarchical, whereas composition is more about assembling functionalities.

Example:

// Inheritance example
public class Animal
{
    public void Eat() => Console.WriteLine("Eating");
}

public class Dog : Animal
{
    public void Bark() => Console.WriteLine("Barking");
}

// Composition example
public class Engine
{
    public void Start() => Console.WriteLine("Engine started");
}

public class Car
{
    private Engine engine = new Engine();

    public void Start()
    {
        engine.Start(); // Composition used here
        Console.WriteLine("Car started");
    }
}

2. Can you demonstrate a simple example of composition in C#?

Answer: Composition in C# can be demonstrated by creating a class that contains objects of other classes. This indicates a has-a relationship, where the containing class can utilize the functionalities of the contained classes.

Key Points:
- Composition allows for flexible and maintainable designs.
- Enhances encapsulation by only exposing relevant methods.
- Facilitates code reuse without the tight coupling that inheritance can introduce.

Example:

public class Processor
{
    public void ProcessData() => Console.WriteLine("Processing data");
}

public class Computer
{
    private Processor processor = new Processor();

    public void StartProcessing()
    {
        processor.ProcessData(); // Utilizing composition
        Console.WriteLine("Computer started processing data");
    }
}

3. How does composition solve the problem of multiple inheritance in C#?

Answer: C# does not support multiple inheritance directly due to the diamond problem and complexity it introduces. Composition is a widely accepted workaround that allows a class to have the functionalities of multiple classes without the need for multiple inheritance. By containing instances of other classes, a single class can leverage multiple behaviors and functionalities.

Key Points:
- Avoids the diamond problem associated with multiple inheritance.
- Promotes loose coupling, making code more modular and maintainable.
- Enables the class to use functionalities of multiple classes without inheriting from them.

Example:

public class Camera
{
    public void TakePhoto() => Console.WriteLine("Photo taken");
}

public class Phone
{
    public void MakeCall() => Console.WriteLine("Calling");
}

// Utilizing composition to have the functionalities of both Camera and Phone
public class Smartphone
{
    private Camera camera = new Camera();
    private Phone phone = new Phone();

    public void TakePhoto()
    {
        camera.TakePhoto();
    }

    public void MakeCall()
    {
        phone.MakeCall();
    }
}

4. Discuss the impact of using composition over inheritance in terms of software design patterns and principles.

Answer: Choosing composition over inheritance can significantly impact the application of design patterns and the adherence to SOLID principles in software development. It promotes greater flexibility and decoupling, making systems easier to understand, modify, and extend.

Key Points:
- SOLID Principles: Composition supports the Dependency Inversion Principle by facilitating dependency injection and makes it easier to adhere to the Liskov Substitution Principle by not forcing subclasses to implement irrelevant methods.
- Design Patterns: Many design patterns, such as Strategy, Decorator, and Composite patterns, rely on composition to achieve extensibility and flexibility.
- Composition fosters better encapsulation and modularity, as changes in the components do not directly impact the composite class's consumers.

Example:

// Strategy pattern utilizing composition
public interface ISortingStrategy
{
    void Sort(List<int> data);
}

public class QuickSort : ISortingStrategy
{
    public void Sort(List<int> data) => Console.WriteLine("QuickSort algorithm");
}

public class Context
{
    private ISortingStrategy sortingStrategy;

    public Context(ISortingStrategy strategy)
    {
        this.sortingStrategy = strategy;
    }

    public void SetStrategy(ISortingStrategy strategy)
    {
        this.sortingStrategy = strategy;
    }

    public void SortData(List<int> data)
    {
        sortingStrategy.Sort(data);
        Console.WriteLine("Data sorted");
    }
}

This example demonstrates how composition, used in the Strategy pattern, allows for dynamic changes in the algorithm used by an object at runtime, enhancing flexibility and enabling adherence to SOLID principles.