UML Class Relationships and Hierarchies in Object-Oriented Programming

Common multiplicity notations include:

• 1: Mandatory one connection.
• 0..1: Optional (zero or one) connection.
• 1..*: Mandatory (one or many) connection.
• 0..*: Optional (zero or many) connection.

Generalization Hierarchies

Generalization is a way to classify objects into groups that share common characteristics. This creates a "is-a" relationship, where a more specific class (the subclass) inherits the attributes and behaviors of a more general class (the superclass).

Inheritance Types

The way these hierarchies are structured can vary:

1. Single Inheritance: A child class derives from one parent class.
2. Hierarchical Inheritance: Multiple subclasses inherit from a single parent (e.g., Dog, Cat, and Bird all inherit from Animal).
3. Multilevel Inheritance: A chain of inheritance where a class inherits from a parent, which in turn inherits from a grandparent.
4. Multiple Inheritance: A single child class inherits from two or more different parent classes.
5. Hybrid Inheritance: A combination of two or more of the above types.

Exam Tip: In a UML diagram, generalization is represented by a solid line with a closed, unfilled arrowhead pointing toward the superclass.

Assembly Structures: Aggregation vs. Composition

Sometimes, relationships are not about "is-a" (inheritance), but about "has-a" or "part-of". These are known as assembly structures.

Aggregation (Weak "Has-a")

Aggregation is a relationship where one object is the "whole" and the other is the "part". Crucially, in aggregation, the part can exist independently of the whole. For example, a Team has Players; if the team is disbanded, the players still exist. In UML, this is shown with a hollow diamond at the "whole" end.

Composition (Strong "Has-a")

Composition is a much stronger form of association. In composition, the child object's life cycle is dependent on the parent. The part cannot exist without the whole. For example, a House is composed of Rooms; if the house is destroyed, the rooms are also destroyed. In UML, this is represented by a filled diamond at the "whole" end.

Interfaces: The Contractual Relationship

An interface is a way to specify what a class must be able to do, without specifying how it does it. It acts as a contract. If a class "implements" an interface, it is making a promise to provide the specific methods defined by that interface.

Unlike inheritance, which describes what an object is (e.g., a Car is an Automobile), an interface describes what an object can do (e.g., a Car implements the Drivable interface). This allows developers to write code that works with any object that fulfills the contract, regardless of its specific implementation.