11.5. Aggregation vs Composition

• Aggregation: "Has-a" relationship where both entities can exist independently.

Aggregation describes a relationship where one object contains another, but both can exist independently. For example, a 'Car' object can have an 'Engine' object. Even if the 'Car' is removed, the 'Engine' can exist on its own—this illustrates aggregation. In general terms, think of it like a person owning a book; the book can exist without the person, and the person can exist without the book.

Imagine a teacher and a classroom. A teacher can teach in multiple classrooms, and if a teacher leaves, the classroom remains. Therefore, they have an aggregated relationship where both can exist independently.

• Composition: "Has-a" relationship where the child cannot exist without the parent.

Composition is a stronger form of association than aggregation. In this case, when one object (the parent) is removed, the other object (the child) cannot exist on its own. For example, a 'House' cannot exist without 'Rooms'; if you remove the 'House', the 'Rooms' cease to exist as part of that house structure. This leads us to think of composition as a whole-part relationship.

Consider a tree and its leaves. If the tree dies (parent), the leaves (children) cannot survive or exist independently. This illustrates composition, where the existence of one is dependent on the other.

Example (Aggregation):

class Engine {}
class Car {
    Engine engine; // Car has-a Engine
}

The code shows a simple example of aggregation in Java. The 'Car' class has an attribute 'engine', which is an instance of the 'Engine' class. In this way, a car is characterized by having an engine, but the engine itself does not depend on the car for its existence, exemplifying aggregation.

Think of a library and the books within it. The library is the 'Car', and the books are the 'Engine'. The library can have many books, and the books can exist in other libraries too; thus, they are independent in the aggregation relationship.

--