Association Vs. Aggregation Vs. Composition in Java

Linking classes together is a crucial component of object-oriented programming (OOP), a complex web of interconnectivity. The three basic ideas that underpin these interactions are introduced by Java, a language well-known for its object-oriented principles: association, aggregation, and composition. These ideas not only serve as the foundation for classroom discussions, but they are also essential in the development of flexible and maintainable software.

Association: Connecting Classes

The association becomes the foundation of links between two or more classes in the huge world of Java. It describes complex relationships that can be one-to-one, one-to-many, or many-to-many, going beyond simple connections. Take into account the following characteristics to understand the subtleties of association:

Features of Association

1. Multiplicity

Associations define the relationship between instances of one class and instances of another, and they can take on different multiplicities. For more complicated relationships, this might be one-to-many or many-to-many. One-to-one indicates a single link.

2. Directionality

Association can go into unknown territory in both one-way and two-way directions. One-way connections are fostered by unidirectional association, which suggests that one class is aware of the other. On the other hand, bidirectional association establishes a two-way street by signifying a shared understanding between the two classes.

3. Navigation

Using method calls or direct access to attributes, one must traverse from one class to another while navigating associations. This dynamic interaction is the foundation for building complex systems with flexible class relationships.

Association.java

// Import required libraries
import java.io.*;
import java.util.*;
// Class with name 'Branch' is created
class Branch {
    // Instance variable of the class
    private String name;
    // Parameterized constructor of this class
    Branch(String name) {
        // 'this' keyword is used to refer to the current class
        this.name = name;
    }
    // Method for the class
    public String getBranchName() {
        return this.name;
    }
}
// Class with name 'Student' is created
class Student {
    // Instance variable of the class
    private String name;
    // Parameterized constructor of this class
    Student(String name) {
        // 'this' keyword is used to refer to the current class
        this.name = name;
    }
    // Method of the class
    public String getStudentName() {
        // Returning the name of the student
        return this.name;
    }
}
// Main class
class Association {
    // Main method
    public static void main(String[] args) {
        // Using the Scanner class to read inputs from the user
        // Creating an object for the Scanner class
        Scanner sc = new Scanner(System.in);
        // Asking the user to enter the branch name
        System.out.println("Enter branch name of the student");
        // Storing the string in variable 's'
        String s = sc.nextLine();
        // Asking the user to enter the name of the student
        System.out.println("Enter name of the student ");
        // Storing the string in variable 's2'
        String s2 = sc.nextLine();
        // Object creation for classes
        Branch b = new Branch(s);
        Student std = new Student(s2);
        // Accessing methods of classes using objects created for the classes
        System.out.println(std.getStudentName() + " is a student of " + b.getBranchName());
    }
}

Output:

Enter branch name of the student
CSE
Enter name of the student 
RAM
RAM is a student of CSE

Aggregation: The "Whole-Part" Relationship

A more sophisticated kind of connection known as aggregation represents a "whole-part" relationship in which entities are made up of separate parts. Aggregation, as opposed to association, suggests a stronger bond and permits autonomous component operation. Take into account the following characteristics to understand the subtleties of the aggregate symphony:

Features of Aggregation

1. Ownership

A complex feeling of ownership is represented by aggregation. Although it does not have total authority, the "whole" class remains connected to the "part" class. Different wholes can exchange parts, resulting in a shared and dynamic interaction.

2. Flexibility

This type of connection offers adaptability. Parts or components can be added or deleted easily without disrupting the overall framework. This flexibility is essential in many situations involving software design.

3. Lifecycle

Within the domain of aggregation, components may have separate lives from the whole. They add a level of complexity to the design and can exist either before or after the creation or destruction of the entire entity.

Car.java

// Engine class representing the "part" in the aggregation
class Engine {
    private String fuelType;
    // Getter and setter for fuelType
    public String getFuelType() {
        return fuelType;
    }
    public void setFuelType(String fuelType) {
        this.fuelType = fuelType;
    }
    // Other Engine attributes and methods
}
// Car class representing the "whole" in the aggregation
public class Car {
    private String model;
    private Engine engine; // Aggregation
    // Getter and setter for model
    public String getModel() {
        return model;
    }
    public void setModel(String model) {
        this.model = model;
    }
    // Getter and setter for engine
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    // Other Car attributes and methods
    // Method to display information about the car
    public void displayCarInfo() {
        System.out.println("Car Model: " + getModel());
        System.out.println("Engine Fuel Type: " + getEngine().getFuelType());
    }
    // Main method
    public static void main(String[] args) {
        Engine carEngine = new Engine();
        carEngine.setFuelType("Petrol");
        Car myCar = new Car();
        myCar.setModel("Sedan");
        myCar.setEngine(carEngine);
        myCar.displayCarInfo();
    }
}

Output:

Car Model: Sedan
Engine Fuel Type: Petrol

Composition

In the domain of aggregation, composition appears as a more rigid form in which every element depends exclusively on the presence of the whole. Because of their strong ties, the constituent parts and the whole are produced and, most importantly, destroyed together. Let us examine the characteristics that characterize this interdependence:

Features of Composition

1. Ownership and Lifecycle

Composition introduces a strong form of ownership. The "whole" class is in charge of both the creation and destruction of the "part" class and also possessing it. Their closely entwined life cycles promote a harmonious and symbiotic interaction.

2. Responsibility

The composition as a whole is in charge of controlling the behavior and lifetime of its constituent parts. It increased sense of accountability makes the structure closer-knit and more dependent on one another.

3. Immutability

Immutability can result from composition in some situations. After it is fully formed, an entity's components become immutable, strengthening the structure and preventing changes.

Human.java

// Heart class representing the "part" in the composition
class Heart {
    // Heart attributes and methods
    // Example method for the Heart class
    public void beat() {
        System.out.println("Heart is beating...");
    }
}
// Human class representing the "whole" in the composition
public class Human {
    private String name;
    private Heart heart; // Composition

    // Constructor for the Human class
    public Human(String name) {
        this.name = name;
        this.heart = new Heart();
    }
    // Getter for the name attribute
    public String getName() {
        return name;
    }
    // Getter for the heart attribute
    public Heart getHeart() {
        return heart;
    }
    // Example method for the Human class
    public void walk() {
        System.out.println(getName() + " is walking.");
    }
    // Main method
    public static void main(String[] args) {
        Human person = new Human("Alice");
        // Accessing methods of the Human and Heart classes using objects
        person.walk();
        person.getHeart().beat();
    }
}

Output:

Alice is walking.
Heart is beating.

Use Cases

Association

When there is a generic relationship between classes but little ownership or reliance, use association.

Aggregation

When one class represents a collection of another class, yet each part can exist separately, use aggregation.

Composition

When the components are essential to the whole and have a closely linked lifespan, use composition.

Feature	Association	Aggregation	Composition
Relationship Type	Generic relationship between two or more classes.	"Whole-Part" relationship where the parts can exist independently.	"Whole-Part" relationship with stronger bonds, where parts are dependent on the whole.
Dependency Level	Lower dependency: classes can exist independently.	Moderate dependency: parts can exist independently of the whole.	Higher dependency; parts are destroyed along with the whole.
Code Reusability	Higher classes can be reused in different contexts.	Moderate; parts can be reused in different wholes.	Lower: specific components designed for a particular whole.
Flexibility	Higher; changes in one class don't necessarily affect the other.	Moderate; changes in parts might affect the whole, and vice versa.	Lower changes in one component can significantly impact the whole.
Example	Student and Branch classes form a basic relationship.	Car and Engine classes where the Engine is part of the Car.	Human and Heart classes where the Heart is an integral part of a Human.
Representation in Code	No specific keywords, just objects of different classes interacting.	Use of class variables to represent parts and the whole.	Use of class variables and instantiation within the constructor to create a composition.
Code Complexity	Lower : simple relationships between classes.	Moderate: managing the relationship between parts and the whole.	Higher: managing dependencies and ensuring proper destruction.

Conclusion

Association: It promotes code reusability and flexibility by representing a generic relationship between classes with fewer dependencies.
Aggregation: It denotes a somewhat dependent "whole-part" relationship. Sections can function alone and utilized again in other situations.
Composition: It creates a more dependent, stronger "whole-part" relationship. The pieces being destroyed together create stronger relationships but less code reusability.

Depending on the particular requirements and interactions between classes in a given design, one can choose between association, aggregation, and composition. Each is necessary to build reliable and manageable Java object-oriented systems.

Next TopicCovariant and Contravariant Java

← prev next →