Clean • Professional
In Object-Oriented Programming (OOP), classes often work together — objects interact and depend on each other.
These relationships between classes are known as Association, Aggregation, and Composition. They describe “how objects are related” and “how strongly one object depends on another.”
Association represents a relationship between two separate classes that are connected through their objects.
It shows how one object uses or interacts with another — but both objects can exist independently.
Example – Association
class Teacher {
String name;
Teacher(String name) { this.name = name; }
}
class Student {
String name;
Student(String name) { this.name = name; }
void studyWith(Teacher t) {
System.out.println(name + " studies with " + t.name);
}
}
public class AssociationExample {
public static void main(String[] args) {
Teacher teacher = new Teacher("Mr. Sharma");
Student student = new Student("Aman");
student.studyWith(teacher);
}
}
Output:
Aman studies with Mr. Sharma
Explanation:
[Student] ↔ [Teacher]
(Both can exist independently)Aggregation is a special form of association where one class contains a reference to another class, but both can still exist independently. It represents a “Has-A” relationship with weak ownership.
For example:
A Department has Teachers, but Teachers can exist even if the Department is deleted.
Example – Aggregation
class Department {
String name;
Department(String name) { this.name = name; }
}
class Teacher {
String name;
Department department; // Aggregation
Teacher(String name, Department department) {
this.name = name;
this.department = department;
}
void showInfo() {
System.out.println(name + " belongs to " + department.name + " department.");
}
}
public class AggregationExample {
public static void main(String[] args) {
Department dept = new Department("Computer Science");
Teacher t1 = new Teacher("Neha", dept);
Teacher t2 = new Teacher("Ravi", dept);
t1.showInfo();
t2.showInfo();
}
}
Output:
Neha belongs to Computer Science department.
Ravi belongs to Computer Science department.
[Department]
↓
[Teacher 1]
[Teacher 2]
(Department has Teachers — but Teachers can exist independently)Composition is a stronger form of aggregation. Here, the lifetime of the contained object depends on the container object.
If the container (main object) is destroyed, contained objects are also destroyed.
Example – Composition
class Engine {
void start() {
System.out.println("Engine starts...");
}
}
class Car {
private Engine engine; // Composition
Car() {
engine = new Engine(); // Engine created inside Car
}
void startCar() {
engine.start();
System.out.println("Car is moving...");
}
}
public class CompositionExample {
public static void main(String[] args) {
Car car = new Car();
car.startCar();
}
}
Output:
Engine starts...
Car is moving...
Explanation:
[Car] → [Engine]
(Engine exists only as part of Car — strong ownership)Car object owns the Engine object.Car is destroyed, its Engine also ceases to exist.| Feature | Association | Aggregation | Composition |
|---|---|---|---|
| Definition | General relationship between two classes | Weak “Has-A” relationship | Strong “Has-A” relationship |
| Dependency | Objects are independent | Contained object can exist without container | Contained object cannot exist without container |
| Ownership | No ownership | Partial ownership | Full ownership |
| Lifetime | Independent | Separate lifetimes | Shared lifetime (dependent) |
| Example | Student ↔ Teacher | Department → Teacher | Car → Engine |
| Real-World Object | Relationship Type |
|---|---|
| Student ↔ Library | Association |
| Company → Employees | Aggregation |
| Human → Heart | Composition |
| Computer → CPU | Composition |
Association → Student ↔ Library (Independent)
Aggregation → Company → Employees (Weak ownership)
Composition → Human → Heart (Strong ownership)