Association, Aggregation and Composition

Introduction

Relationships between classes in Java describe how objects of different classes connect, interact, or depend on one another.

The three common class relationships are:

Association
Aggregation
Composition

Association is a general connection between classes, while aggregation and composition represent different strengths of a whole-part or has-a relationship. In UML, aggregation and composition are represented as specialized relationships between objects.

1. Association in Java

Association is a relationship in which objects of two independent classes interact with each other.

Neither object owns the other, and both can exist independently.

For example, a doctor treats a patient. The doctor and patient can exist separately even when they are not connected.

Association Example

1// Patient is an independent class
2class Patient {
3
4    // Store the patient's name
5    String name;
6
7    // Initialize the patient's name
8    Patient(String name) {
9        this.name = name;
10    }
11}
12
13// Doctor is another independent class
14class Doctor {
15
16    // Store the doctor's name
17    String name;
18
19    // Initialize the doctor's name
20    Doctor(String name) {
21        this.name = name;
22    }
23
24    // Doctor uses a Patient object temporarily
25    void treat(Patient patient) {
26        System.out.println(name + " treats " + patient.name + ".");
27    }
28}
29
30public class Main {
31    public static void main(String[] args) {
32
33        // Create both objects independently
34        Doctor doctor = new Doctor("Dr. Meera");
35        Patient patient = new Patient("Rahul");
36
37        // Create an association through method interaction
38        doctor.treat(patient); // Output :- Dr. Meera treats Rahul.
39    }
40}

Here, the Doctor object uses the Patient object, but neither object owns the other.

Association

2. Aggregation in Java

Aggregation is a weak has-a relationship in which one class contains a reference to an object of another class.

The contained object is created independently and can continue to exist without the container object.

For example, a department has teachers, but a teacher can exist without that particular department.

Aggregation Example

1// Teacher can exist independently
2class Teacher {
3
4    // Store the teacher's name
5    String name;
6
7    // Initialize the teacher's name
8    Teacher(String name) {
9        this.name = name;
10    }
11}
12
13// Department contains a reference to Teacher
14class Department {
15
16    // Reference to an independently created Teacher
17    Teacher teacher;
18
19    // Receive the Teacher object from outside
20    Department(Teacher teacher) {
21        this.teacher = teacher;
22    }
23
24    // Display the aggregated object's information
25    void showTeacher() {
26        System.out.println("Teacher: " + teacher.name);
27    }
28}
29
30public class Main {
31    public static void main(String[] args) {
32
33        // Create the Teacher independently
34        Teacher teacher = new Teacher("Anita");
35
36        // Pass the existing Teacher to the Department
37        Department department = new Department(teacher);
38
39        // Access the Teacher through the Department
40        department.showTeacher(); // Output :- Teacher: Anita
41    }
42}

The Department contains a Teacher, but it does not create that teacher. The Teacher object can still exist independently.

Aggregation

3. Composition in Java

Composition is a strong has-a relationship in which one class owns an object of another class.

The contained object is created and managed by the owner and is not intended to exist independently from it.

For example, a house contains rooms that belong to that house.

Composition Example

1// Room represents a part of a House
2class Room {
3
4    // Store the type of room
5    String type;
6
7    // Initialize the room type
8    Room(String type) {
9        this.type = type;
10    }
11}
12
13// House strongly owns its Room
14class House {
15
16    // Room is stored as part of the House
17    private Room room;
18
19    // House creates and manages its own Room
20    House() {
21        room = new Room("Bedroom");
22    }
23
24    // Display information about the owned Room
25    void showRoom() {
26        System.out.println("House contains: " + room.type);
27    }
28}
29
30public class Main {
31    public static void main(String[] args) {
32
33        // Creating a House also creates its Room
34        House house = new House();
35
36        // Access the Room through the House
37        house.showRoom(); // Output :- House contains: Bedroom
38    }
39}

In this example, the House creates and owns the Room. The room is treated as a part of that specific house.

Composition

Association vs Aggregation vs Composition

Relationship	Meaning	Ownership	Object Life Cycle	Example
Association	One object interacts with another	No ownership	Both objects are independent	Doctor and Patient
Aggregation	Weak has-a relationship	Weak ownership	The part can exist independently	Department and Teacher
Composition	Strong has-a relationship	Strong ownership	The part depends logically on the whole	House and Room

Summary

Association, aggregation, and composition describe how Java classes interact.

Association connects independent objects. Aggregation creates a weak has-a relationship in which the contained object can exist independently. Composition creates a stronger relationship in which the contained object is owned and managed by the containing object.