Course: Core Java Training
Topic: Working with Composition and Aggregation
Course URL: Core Java Training Course
Demo URL: Register for a Course Demo
Website: JustAcademy
Java is an object-oriented programming language that allows developers to model real-world relationships between objects. In addition to inheritance, Java supports relationships in which one object contains or uses another object. These relationships are commonly described as has-a relationships.
Composition and aggregation are two important forms of relationships between classes. Both allow one class to hold references to objects of another class, but they differ in ownership, independence, and object lifecycle.
For example, a computer contains components such as a motherboard, while a department may have employees who can continue working even if the department is reorganized. These scenarios help explain the difference between strong ownership and a looser relationship.
A has-a relationship exists when an object contains a reference to, or uses, another object as part of its functionality. Composition and aggregation are both forms of this relationship.
For example, consider a Car class that contains an Engine object. The car uses the engine to perform its operations. A Department class may contain references to several Employee objects.
class Engine {
void start() {
System.out.println("Engine started.");
}
}
class Car {
private Engine engine;
Car() {
engine = new Engine();
}
void startCar() {
engine.start();
System.out.println("Car is ready.");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.startCar();
}
}Output:
Engine started.
Car is ready.The Car class contains an Engine reference and calls its method. This example illustrates a has-a relationship implemented through object composition.
Composition is a strong whole-part relationship in which one object owns another object as an integral part of its design. The contained object's lifecycle is generally managed by the owning object, and the contained part is not intended to exist independently within that domain model.
Composition is useful when an object is responsible for creating, managing, and using the objects that form its internal structure.
These examples are design choices rather than universal rules. The correct relationship depends on whether the part is independently managed or owned by the whole in the application being developed.
Composition can be implemented by creating an object of one class inside another class. The owning class stores the object in a field and uses it to perform its operations.
class Processor {
void process() {
System.out.println("Processor is processing data.");
}
}
class Computer {
private final Processor processor;
Computer() {
processor = new Processor();
}
void start() {
processor.process();
System.out.println("Computer started.");
}
}
public class Main {
public static void main(String[] args) {
Computer computer = new Computer();
computer.start();
}
}Output:
Processor is processing data.
Computer started.Processor class defines a method called process().Computer class contains a private reference to a Processor object.start() method uses the processor to perform work.main() method creates a computer and starts it.The final modifier prevents the processor reference from being reassigned after initialization. It does not make the referenced object itself immutable.
Aggregation is a weaker whole-part relationship in which one object holds references to other objects that can exist independently of the containing object.
For example, a department may have employees. If the department is removed or reorganized, the employee objects can continue to exist and may be assigned to another department.
Aggregation is commonly implemented by passing an existing object to another class through a constructor or setter method. The receiving class stores the reference and uses the object without necessarily owning its lifecycle.
class Employee {
private final String name;
Employee(String name) {
this.name = name;
}
String getName() {
return name;
}
}
class Department {
private final String departmentName;
private final Employee employee;
Department(String departmentName, Employee employee) {
this.departmentName = departmentName;
this.employee = employee;
}
void displayDetails() {
System.out.println("Department: " + departmentName);
System.out.println("Employee: " + employee.getName());
}
}
public class Main {
public static void main(String[] args) {
Employee employee = new Employee("Amit");
Department department =
new Department("Information Technology", employee);
department.displayDetails();
System.out.println("Employee still exists: "
+ employee.getName());
}
}Output:
Department: Information Technology
Employee: Amit
Employee still exists: AmitEmployee object is created independently.Department constructor.This demonstrates aggregation because the employee is created outside the department and can be used independently. Java does not enforce aggregation as a separate language feature; the relationship is established through the program's design and ownership rules.
| Feature | Composition | Aggregation |
|---|---|---|
| Relationship | Strong whole-part relationship | Weak whole-part relationship |
| Ownership | The whole owns the part in the domain model | The whole references a part that remains independently managed |
| Lifecycle | Usually managed with the whole | Independent of the whole |
| Object creation | Often created within the owning class | Often created externally and passed in |
| Independent existence | Part is not intended to exist independently within the modeled relationship | Part can exist without the containing object |
| Sharing | Exclusive ownership is generally intended | Sharing may be possible |
| Example | Order and its line items | Department and employees |
| Typical implementation | Private fields initialized and managed by the owner | References supplied through constructors or setters |
Java uses garbage collection to reclaim objects that are no longer reachable. It does not automatically destroy an object's referenced parts merely because the containing object is no longer used.
Therefore, the difference between composition and aggregation is primarily a matter of ownership and domain design, rather than a special Java keyword or automatic destruction rule.
Important: Garbage collection depends on object reachability, not simply on whether a particular reference is called a composition or aggregation relationship.
Both composition and aggregation can use constructors or setter methods to connect objects. The choice depends on how the application manages the relationship.
Constructor injection supplies a dependency when an object is created. It is useful when the dependency is required for the object to function correctly.
class Printer {
void print() {
System.out.println("Printing...");
}
}
class Office {
private final Printer printer;
Office(Printer printer) {
this.printer = printer;
}
void printDocument() {
printer.print();
}
}In this example, an existing Printer is supplied to Office. This can model aggregation when the printer is independently managed.
Setter injection supplies or changes a dependency after the object has been created. It is useful when a dependency is optional or can be replaced.
class MusicPlayer {
void play() {
System.out.println("Music is playing.");
}
}
class Car {
private MusicPlayer musicPlayer;
void setMusicPlayer(MusicPlayer musicPlayer) {
this.musicPlayer = musicPlayer;
}
void playMusic() {
if (musicPlayer != null) {
musicPlayer.play();
} else {
System.out.println("No music player connected.");
}
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.setMusicPlayer(new MusicPlayer());
car.playMusic();
}
}Output:
Music is playing.The way the object is supplied does not, by itself, determine whether the relationship is composition or aggregation. Ownership and lifecycle semantics determine the intended relationship.
Association is the general relationship between objects that interact with one another. Aggregation and composition are specialized whole-part forms of association, while inheritance models an is-a relationship.
| Concept | Meaning | Example |
|---|---|---|
| Association | Objects are related or communicate with each other | Doctor and Patient |
| Aggregation | A whole references independently existing parts | Team and Player |
| Composition | A whole owns parts as an integrated structure | Order and OrderItem |
| Inheritance | One class extends another class to specialize its behavior | Car extends Vehicle |
class Vehicle {
void move() {
System.out.println("Vehicle is moving.");
}
}
class Car extends Vehicle {
void openTrunk() {
System.out.println("Trunk opened.");
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car();
car.move();
car.openTrunk();
}
}Output:
Vehicle is moving.
Trunk opened.The car is a vehicle, so inheritance models an is-a relationship. Composition and aggregation instead model has-a relationships.
An online shopping system can use composition for an order and its line items, while using aggregation to associate an order with a customer who exists independently of that order.
import java.util.ArrayList;
import java.util.List;
class Customer {
private final String name;
Customer(String name) {
this.name = name;
}
String getName() {
return name;
}
}
class OrderItem {
private final String product;
private final int quantity;
OrderItem(String product, int quantity) {
this.product = product;
this.quantity = quantity;
}
void display() {
System.out.println(product + " x " + quantity);
}
}
class Order {
private final Customer customer;
private final List<OrderItem> items = new ArrayList<>();
Order(Customer customer) {
this.customer = customer;
}
void addItem(String product, int quantity) {
items.add(new OrderItem(product, quantity));
}
void displayOrder() {
System.out.println("Customer: " + customer.getName());
System.out.println("Order items:");
for (OrderItem item : items) {
item.display();
}
}
}
public class Main {
public static void main(String[] args) {
Customer customer = new Customer("Neha");
Order order = new Order(customer);
order.addItem("Laptop", 1);
order.addItem("Mouse", 2);
order.displayOrder();
}
}Output:
Customer: Neha
Order items:
Laptop x 1
Mouse x 2Customer is created separately and passed into the order, illustrating aggregation.Order creates its own OrderItem objects through addItem(), illustrating composition by design.This is a simplified example. In a production application, an order may need persistent identifiers, validation, pricing, inventory checks, and database transaction management.
composition or aggregation keywords.House class and a Room class to demonstrate composition.School class and a Student class to demonstrate aggregation.Library class that stores references to independently created Book objects.Computer class containing a Motherboard object managed by the computer.Project references independently managed Developer objects.Composition is a strong whole-part relationship in which a containing object owns and manages its component objects as part of its internal structure.
Aggregation is a weaker whole-part relationship in which one object references other objects that can exist independently of the containing object.
The key difference is ownership and lifecycle. Composition implies strong ownership of parts, whereas aggregation allows the referenced parts to have independent lifecycles.
No. They are object-oriented design concepts implemented using ordinary classes, object references, constructors, fields, and methods.
Yes. An existing object can be passed into a constructor and stored as a field. This is a common way to establish an aggregation relationship.
Yes. A class can own a collection of component objects, such as an order owning its line items. The class should manage the collection according to the intended lifecycle and business rules.
No. Java uses garbage collection. An object becomes eligible for garbage collection when it is no longer reachable, regardless of whether the program models the relationship as composition or aggregation.
Aggregation is a specialized whole-part form of association. Association is the more general term for relationships between objects.
Composition allows a class to reuse the behavior of other objects without creating a rigid inheritance hierarchy. It can improve flexibility and separation of responsibilities.
A department referencing employee objects is a common example because employees can continue to exist independently of a particular department.
An order owning its order-line objects is a common example when those line items are managed as parts of that order.
Yes. A class can own some objects while referencing other independently managed objects. The relationship depends on the role and ownership of each object.
Composition and aggregation are important object-oriented design concepts in Java. Composition represents strong ownership of components, while aggregation represents a relationship with objects that remain independently managed. Both can help developers build modular, reusable, and maintainable applications.
Understanding these relationships helps you select appropriate class structures, manage dependencies, and model real-world business requirements accurately. Practice implementing both approaches and pay attention to object ownership, encapsulation, and lifecycle expectations.
Explore the Core Java Training Course to strengthen your understanding of object-oriented programming and Java application development.
Register for a Course Demo to learn more about the training program.
Visit JustAcademy to explore additional courses and learning resources.
