Composition over Inheritance

The principle of Composition over Inheritance is a design principle in object-oriented programming, suggesting that it can be more beneficial to build complex objects by composing them of simple objects rather than trying to use a hierarchical inheritance structure to describe their behavior and attributes.

Here's a detailed explanation of each approach:

Inheritance: This is a way to form new classes using classes that have already been defined. The new classes, known as derived classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes. However, this approach can lead to problems due to its inflexibility when a base class is modified, or the derived class is overburdened with many inherited features it doesn't need.
Composition: This refers to building complex objects by combining simpler ones. This means that a class instance controls another object's functions by invoking methods in those objects, or the object can be a simpler data structure. By doing this, you can change behaviors and characteristics of objects at runtime by changing their constituent parts.

The principle of Composition over Inheritance suggests using composition in situations where inheritance could lead to an overly complex structure or when it doesn't fully model the "is-a" relationship. Instead of a derived class inheriting properties from a base class, methods and properties can be passed to it in a more modular and flexible manner.

Here are some reasons why composition is often favored over inheritance:

Flexibility: In composition, you can control when and which components to include, and even change behavior/properties at runtime.
Simplicity: Complex class hierarchy can be hard to understand and maintain, especially when classes inherit behavior that they don't need. With composition, you simply have a set of components each with their own behavior, which makes the structure more straightforward.
Avoids problems of inheritance: Some problems, like the tight coupling between child and parent classes, and issues related to the "diamond problem" in languages supporting multiple inheritances, are avoided with composition.

In summary, while inheritance can still be useful in many cases, favoring composition over inheritance can often result in a more flexible and maintainable design.