Difference Between Aggregation and Composition in Java

An object is a real-time entry, and objects have relationships between them both in programming or real life. Objects are related to each other using more than one relationship, such as Aggregation, Composition, Association, etc.

Let's understand the difference between Aggregation and Composition but before that we understand all these three relationships in detail.

Composition

Composition is a "belong-to" type of relationship in which one object is logically related with other objects. It is also referred to as "has-a" relationship. We can understand has-a or belong-to by using the following example:

A classroom belongs to a school, or we can say a school has a classroom. So, calling both of them is only a matter of point of view.

Composition is a strong type of "has-a" relationship because the containing object is its owner. So, objects are tightly coupled, which means if we delete the parent object, the child object will also get deleted with it.

Let's take an example to understand how we can implement the logic for the Composition relationship in Java:

CompositionExample.java

import java.util.*;   
// create class for Office
class Office {   
    // declare variables for name and address
	public String name;   
    public String address;   
    // initialize name and address variables using constructor
    Office(String name, String address)   
    {   
        this.name = name;   
        this.address = address;   
    }   
}   
// Create a class for Company that has more than one Office.   
class Company {   
	// declare variable for company name
	public String name;
    // declare a list of OfficeOffice that a Company has 
    private final List< Office Office> offices;
    // initialize variable and list using constructor
    Company(String name, List<Office> offices)  
    {  
    	this.name = name;
        this.offices = offices;  
    }   
    // create a getter function to return a list of office 
    public List<Office> getTotalOfficesOfCompany()   
    {   
        return offices;   
    }   
}   
// create class CompositionExample1 to understand Composition example
class CompositionExample {   
	// main() method start
    	public static void main(String[] args)   
    	{   
        		// create objects of Office class.   
       	 	Office o1 = new Office("Google India Pvt. Ltd", "Banglore");   
       		Office o2 = new Office("Google India Pvt. Ltd", "Gurgaon");
        		Office o3 = new Office("Google India Pvt. Ltd", "Hyderabad");
        		Office o4 = new Office("Google India Pvt. Ltd", "Mumbai");
        		// create list which contains the no. of offices   
        		List<Office> offices = new ArrayList<Office>();   
        		offices.add(o1);   
        		offices.add(o2);   
        		offices.add(o3); 
        		offices.add(o4); 
       		 // create an instance of the Company class by passing a list of Office to the constructor
        		Company company = new Company("Google", offices);   
        		System.out.println(company.name+" offices:");
       		 // get total offices of the Company using getter
        		List<Office> data = company.getTotalOfficesOfCompany();
        		// iterate offices of the company 
        		for (Office office : data) {   
        			// print data 
            			System.out.println("Name : " + office.name + " and "+ " Address : " + office.address);  
        		}   
    	}   
}

Output:

Aggregation

Aggregation relationship is also a "has-a" relationship. The only difference between Aggregation and Composition is that in Aggregation, objects are not tightly coupled or don't involve owning. All the objects are independent of each other and can exist even if the parent object gets deleted. Let's understand this by using the following example:

A car comes with a wheel, and if we take off its wheels, the wheels will still exist. But a car without wheels won't be as useful as a car with its wheels, and that's how this relationship existed in the first place for assembling the parts to a bigger construct, which is capable of more things than its parts.

Let's take an example to understand how we can implement the logic for the Aggregation relationship in Java:

Address.java

// create class Address that have fields street, city, state, zip, and country
public class Address {  
	String city,state,country, zip, street;  
	// initialize Address using constructor
	public Address(String street, String city, String state, String zip, String country) {  
		this.city = city;  
		this.state = state;  
		this.country = country;
		this.street = street;  
		this.zip = zip;  
	}  
}

AggregationExample.java

// create AggregationExample class to understand Aggregation concept
public class AggregationExample {  
	// declare variables
	int empId;  
	String empName;  
	Address empAddress;  
	
	// initialize variables using constructor
	public AggregationExample(int empId, String empName, Address empAddress) {  
		this.empId = empId;  
		this.empName = empName;  
    	this.empAddress = empAddress;  
	}  
	// create display() method for showing data
	void display(){  
		System.out.println("Employee Id: "+empId);
		System.out.println("Employee Name: "+empName);  
		System.out.println("Address: "+empAddress.street+""+empAddress.city+" "+empAddress.state+" "+empAddress.zip+" "+empAddress.country);  
	}  
	// main() method start
	public static void main(String[] args) { 
		// create objects of Address class
		Address add1 = new Address("15205 North Kierland Blvd. Suite 100","Scottsdale","AZ", "85254", "America");  
		Address add2 = new Address("2829 Ala Kalanikaumaka, Kukui'ula Village", "Koloa","HI", "96756", "America");  
		
		// create object of AggregationExample by passing value to the constructor
		AggregationExample employee1 = new AggregationExample(001, "Lucy", add1);  
		AggregationExample employee2 = new AggregationExample(002, "Paul", add2);  
		// show data to the users
		employee1.display();  
		employee2.display();  
      
	}  

Output:

Association

Association is not a has-a relationship and the weakest relationship among all. In an Association relationship, none of the objects are parts or members of another. A simple example of Association is a mother and her child.

Let's take an example to understand how we can implement the logic for Association relationships in Java:

AssociationExample.java

import java.util.*;   
// create class Car a Person can have 
class Car {    
	// declare variables for Car brand, color and modal
	public String name, color, modal;  
	// getter and setter for initializing variables
	public String getName() {  
		return name;  
	} 
	public String getColor() {  
		return color;  
	} 
	public String getModal() {  
		return modal;  
	} 
	public void setName(String name) {  
		this.name = name;  
	}
	public void setColor(String color) {  
		this.color = color;  
	}
	public void setModal(String modal) {  
		this.modal = modal;  
	}
}  
// create Person class
class Person {       
	// declare variables for Person class
	public String name;  
	List<Car> cars;
	// getter and setter for initializing variables
	public void showName() {  
		System.out.println(this.name+" has following cars:");
	}  	
	public void setName(String name) {  
		this.name = name;  
	}  
	public void showCars() {  
		for(Car car : cars) {
			System.out.println(car.name+" "+car.modal+" "+car.color);
		}
	}  
	public void setCars(List<Car> cars) {  
		this.cars = cars;  
	}  
}  
// Main class
public class AssociationExample {  
    // main() method start 
	public static void main(String[] args) {  
        // create an object of Person class   
		Person person = new Person();  
		person.setName("Paul");  
		// create objects of Car class
		Car car1 = new Car();  
        car1.setName("Ford BRONCO OUTER BANKS SUV"); 
        car1.setColor("Black");
        car1.setModal("2021");
        Car car2 = new Car();  
        car2.setName("HONDA ODYSSEY EX-L MINIVAN");
        car2.setColor("Brown");
        car2.setModal("2019");
        // create a list of Car
        List<Car> carList = new ArrayList<Car>();  
        carList.add(car1);  
        carList.add(car2);  
        person.setCars(carList);  
        // print details of Person
        person.showName();
        person.showCars();
	}   
}  

Output:

Difference Between Aggregation and Composition

Let's understand the differences between Aggregation and Composition:

S.No.	Aggregation	Composition
1.	Association between two objects that defines the "has-a" relationship is referred to as Aggregation.	A specific type of Aggregation that implies ownership is referred to as Composition.
2.	In Aggregation, objects can remain in the scope of a system without each other.	In a composition relationship, objects cannot remain in the scope of a system without each other.
3.	In Aggregation, linked objects are independent of each other.	In Composition, objects are tightly coupled or dependent on each other.
4.	In Aggregation, if we delete the parent object, the child object will still exist in the system. For example, if we remove wheels from a car, the car can function adequately with another wheel.	In Composition, if we delete a parent object, the child object also gets deleted. For example, if we delete a folder, the files will also get deleted which contain in the folder.
5.	We represent it by using the filled diamond.	We represent it by using the empty diamond.
6.	In Aggregation, child objects don't have a lifetime.	In Composition, child objects have a lifetime.
7.	In Aggregation, if we delete an assembly, it will never affect its parts.	In the case of owning a class, it affects the containing class object.