Object Inheritance and Object Composition in Object Oriented Programming

Today, we are going to delve into two fundamental concepts in Object-Oriented Programming (OOP): Object Inheritance and Object Composition. These concepts are the backbone of OOP, and understanding them is crucial for any programmer working with OOP languages, such as C#.

Object Inheritance

Inheritance is a mechanism that allows one class to inherit the properties and methods of another class. The class being inherited is called the 'base' or 'parent' class, while the class that does the inheriting is known as the 'derived' or 'child' class.

• Importance: Inheritance promotes code reusability and is a way to achieve runtime polymorphism. It allows developers to create new classes from existing ones, reducing redundancy and making the code more maintainable.
• Drawbacks: Despite its advantages, inheritance can lead to a high level of coupling between classes, making the code more rigid and harder to modify. It can also lead to confusion when dealing with large codebases due to the 'is-a' relationship it creates.

Object Composition

Object Composition is a design principle in OOP where a class is composed of other classes. It represents a 'has-a' relationship, meaning that one class has a reference to one or more classes.

• Importance: Composition allows for greater flexibility by enabling you to change behavior at runtime by changing the classes that a class is composed of. It also promotes code reusability and encapsulation.
• Drawbacks: The main drawback of composition is that it can lead to a large number of small classes, each with a very specific role. This can make the code harder to understand and maintain.

Comparison
 

Object Inheritance	Object Composition
Promotes code reusability	Promotes code reusability
Creates 'is-a' relationship	Creates 'has-a' relationship
This can lead to high coupling	This can lead to many small classes
Less flexible	More flexible

Real-life Example in C#

Let's consider a real-life example to understand these concepts better. Suppose we have a 'Vehicle' class and a 'Car' class. In the case of inheritance, the 'Car' class would inherit from the 'Vehicle' class.

Inheritance Example

public class Vehicle
{
    public string Color { get; set; }
    public void Drive()
    {
        Console.WriteLine("Driving...");
    }
}
public class Car : Vehicle
{
    public string Model { get; set; }
    public void Honk()
    {
        Console.WriteLine("Honking...");
    }
}

In this example, the Vehicle class has a property Color and a method Drive(). The Car class inherits from Vehicle, meaning it has access to the Color property and Drive() method. Additionally, it has its own property Model and method Honk().

Composition Example

public class Vehicle
{
    public string Color { get; set; }
    public void Drive()
    {
        Console.WriteLine("Driving...");
    }
}
public class Car
{
    private Vehicle _vehicle;
    public string Model { get; set; }
    public Car(Vehicle vehicle)
    {
        _vehicle = vehicle;
    }
    public void Honk()
    {
        Console.WriteLine("Honking...");
    }
    public void Drive()
    {
        _vehicle.Drive();
    }
}

In the composition example, the Car class has a reference to a Vehicle object, represented by the _vehicle field. It also has its own property Model and method Honk(). The Drive() method in the Car class calls the Drive() method of the _vehicle object, demonstrating the 'has-a' relationship of composition.

In both examples, a Car can Drive() and Honk(), and has a Model and Color. However, in the inheritance example, this is achieved through an 'is-a' relationship (a Car is a Vehicle), while in the composition example, it's achieved through a 'has-a' relationship (a Car has a Vehicle).

Conclusion

Both Object Inheritance and Object Composition have their place in OOP. While inheritance can be useful for extending functionality and promoting code reusability, composition offers greater flexibility and can lead to more maintainable code. As a developer, it's essential to understand these concepts and know when to use each one.