Association, Composition and Aggregation in Java

What is Aggregation in Java?

Aggregation is a particular type of Association. It represents the has-a relationship between the two classes. The relationship between the two classes is entirely independent, which means if one of the objects of the class gets deleted, it won’t affect the other.

The Aggregate class contains a reference to one more class and is said to be responsible for the class. Each class that is referred to is viewed as a piece of the Aggregate class.

Let’s take an easy example. A student attends a school. After the completion of his studies, he can quickly leave school. That means the end of the student object would not destroy the School object. We can say that the Student ‘has-a’ relationship with the school.

To understand the concept better let’s go through the program once.

class Student {
  int id;
  String name;
  String school_name;
  Student(int id, String name, String school_name) { 
    this.id = id;
    this.name = name;
    this.school_name = school_name;
    System.out.println("\nStudent name is " + name);
    System.out.println("Student Id is " + id);
    System.out.println("Student belongs to the " + school_name + "School");
  }
}
class school {
  String schoolName;
  int noOfStudents;
  school(String name, int numberOfStudents) {
    this.schoolName = name;
    this.noOfStudents = numberOfStudents;
  }
}
public class AggregationClass {
  public static void main(String[] args) {
    Student n1 = new Student(1, "NinjaA", "Coding Ninjas");
    Student n2 = new Student(2, "NinjaB", "Code");
    Student n3 = new Student(3, "NinjaC", "XYZ");
  }
}

OUTPUT


Student name is NinjaA
Student Id is 1
Student belongs to the Coding Ninjas School

Student name is NinjaB
Student Id is 2
Student belongs to the Code School

Student name is NinjaC
Student Id is 3
Student belongs to the XYZ School

In the above program, the school and the student represent two individual entities related to each other by a ‘has-a’ relationship. When an object from the student class is deleted, it does not change the object of the School Class. Hence, even though the classes are connected, there is no interdependence between them, as we saw in Association.
We, therefore, say that the Aggregation is a special case of Association.

You can also check out Has-A Relationship in Java here.

What is Composition in Java?

We have just learned about Aggregation as a Special case of Association, and now when we talk about Composition, it is said that Composition is nothing but a restricted type of Aggregation. Let’s have a look at the definition of the concept. Composition in java is a concept which states that there lies a strong relationship between the two objects associated with the given two classes. It is also said to fulfill the “has-a” relationship between the two classes. In composition, the parent class owns the child class which means the child class cannot be a stand-alone entity. We use Composition mainly because it allows us to have Multiple Inheritance in Java, also it will enable us to reuse the code.

Let’s understand this by using a real-life example,

A car needs oil to run, and we know that our car would not be able to start without filling up the gas tank. So this means that even though the car would be useless without the Oil Class, we can say that car and oil have a “has-a” relationship.

The implementation of Composition is given below.

class CarOil {
  public void FillOil() {
    System.out.println("The fuel is full in the car");
  }
  public void EmptyOil() {
    System.out.println("The car has low oil");
  }
} 
 
class Car {
  private String colour;
  private int maxi_Speed;
  public void carDetails(){
    System.out.println("Car Colour= "+colour + ", Maximum Speed= " + maxi_Speed);
  }
  //Setting colour of the car
  public void setColour(String colour) {
    this.colour = colour;
  }
  //Setting maximum car Speed
  public void setMaxiSpeed(int maxi_Speed) {
    this.maxi_Speed = maxi_Speed;
  }
} 
 
class Ninja extends Car {
  public void NinjaOil() {
    CarOil Ninja_Oil = new CarOil(); //composition
    Ninja_Oil.FillOil();
  }
} 
 
public class Main {
  public static void main(String[] args) {   
    Ninja NinjaCar = new Ninja();
    NinjaCar.setColour("Orange");
    NinjaCar.setMaxiSpeed(180);
    NinjaCar.carDetails();
    NinjaCar.NinjaOil();
  }
}

Output

Car Colour= Orange, Maximum Speed= 180
The fuel is full in the car

In this program, the class Ninja is a car that is extended from the Class Car. The CarOil is used in the Ninja class.

Composition offers adaptability and vigorous code. Its code reusability helps in keeping away from code duplication and accomplishing cost-viability, which makes it one of the broadly utilized strategies in different projects.

Also see, Duck Number in Java

Difference Between Association, Aggregation, Composition in Java

Here's a table summarizing the differences between association, aggregation, and composition in Java:

Frequently Asked Questions

What is the difference between Association and Aggregation?

Association means the relationship between the two interdependent classes. The connection is established using the two objects. Through association, a class can use another class component. Whereas, Aggregation is a particular case of Association in which the two classes are related to each other, and they follow a whole and part relationship.

What is the difference between Association and Composition?

Association means to specify a relationship between two classes using their objects. It allows multiple types of relationships like one-to-one, one-to-many, many-to-one, and many-to-many. In contrast, Composition is a restricted Aggregation, which means as per aggregation, it allows the relationship between the two classes, but the objects are dependent on each other. In Composition, only a one-to-one relationship is valid.

What is Aggregation and composition in Java with real life example?

In Java, aggregation represents a "has-a" relationship, where one class contains another class as part of its structure, but they can exist independently. Example: A university "has" departments. Composition is a stronger relationship, where one class owns another class, and the owned class cannot exist independently. Example: A car "has" an engine.

What are the advantages of composition and aggregation?

Composition and aggregation offer key advantages in OOP: Composition ensures strong ownership and lifecycle management, where a part cannot exist independently of its whole. Aggregation allows for a more flexible relationship where the part can exist independently of the whole. Both promote modular, reusable, and maintainable code structures.

Conclusion

In the above article, we learned about the key terms in Object-Oriented Programming: Association, Aggregation, and Composition.
Association means to have a has-a relationship between the two classes, which are specified by their Objects. Association is used to establish a relationship between the two classes through their objects.
Aggregation is just a particular type of Association that offers only one-to-one relationships. In Aggregation, the objects are independent of each other, which means that they can exist independently.
Composition, on the other hand, is a restricted Aggregation. It also offers only a one-to-one relationship between the two classes, but the objects in Composition depend on each other. They hence cannot exist solely(without each other). The article discussed each topic with easy examples.

Also Read :

• Java as an Object-Oriented Language
• Difference Between Rank and Dense Rank

You can also practice problems on Code360. If you liked this blog, share it with your friends.