This blog post aims to explain object-oriented programming concepts and the distinctions between relationship types like association, aggregation, and composition. It also delves into the comparison between inheritance and composition.
Relationship Types
I utilized UML diagrams to visually represent object-oriented programming concepts.
1. Association
Association describes the relationship between classes where objects of one class are connected to objects of another class.
2. Aggregation and Composition
Aggregation and composition are two types of association. Both aggregation and composition establish a “has-a” relationship between objects of different classes. Aggregation represents a weak relationship where an object can exist without its parent object.
Composition indicates a strong relationship where an object cannot exist without its parent object. For this reason we can say that composition is a design technique aimed at implementing a “part-of” relationship between objects. For example, for a human to exist, they must have a heart; if the heart is removed, the human cannot exist.
3. Inheritance
Inheritance is the process where a class inherits the properties and methods of another class, creating an “is-a” relationship between objects. Object-oriented programming supports five main types of inheritance:
1. Single Inheritance
A class inherits from only one base class.
2. Multilevel Inheritance
A class derives from another class, and then another class derives from it, creating a chain of inheritance.
3. Hierarchical Inheritance
Multiple classes inherit from a single base class. Each derived class represents a specialization of the base class.
4. Multiple Inheritance
A class can inherit from more than one base class. This can lead to complexities and is not supported by Java; however, we can achieve this using interfaces.
5. Hybrid (or Virtual) Inheritance
A combination of two or more types of inheritance mentioned above. It is a mix of single, multiple, or multilevel inheritance to exploit the advantages of different types.
Inheritance vs. Composition
Prefer Composition Over Inheritance: Why?
1. Coupling
Inheritance is tightly coupled: Changes in the base class can impact the derived classes, creating a strong dependency within the inheritance hierarchy. The child class inherits methods it may never use, resulting in confusing and hard-to-maintain code.
Composition is loosely coupled: Classes are more independent, and changes in one class are less likely to affect another. Composition allows for flexible relationships between classes that can be established at runtime.
2. Method Override and Code Duplication
Overriding a method in a subclass leads to code duplication, violating the principles of clean code practices.
3. Constructor Execution
When a class inherits from another, the superclass’s constructor always executes before the subclass is loaded.
4. Code Reuse and Diamond Problem
While inheritance provides code reuse, it can lead to issues like the diamond problem. A diamond problem can occur when a class inherits from multiple base classes, which is not supported in Java. Composition, however, allows for better reuse of functionality through interfaces or by incorporating instances of other classes.
5. Unit Testing and Debugging
Composition makes unit testing and debugging easier as each class’s behavior is more independent, allowing for isolated testing.
In summary, while inheritance might be suitable for simpler applications, especially in scenarios where the future is uncertain and constantly evolving, composition tends to offer more flexibility and extendability. The loosely coupled nature of composition contributes to more maintainable and adaptable code in complex systems.
Home 