Association
Association
In object-oriented programming, relationships between classes play a crucial role in defining how objects
interact with each other. Java, being an object-oriented language, provides mechanisms to model these
relationships through association, aggregation, and composition. Aggregation, association,
and composition in Java describe how instances of classes relate to each other.
An association can be considered a generic term to indicate the relationship between two independent
classes; the relationship may be one-to-one, one-to-many, or many-to-many, but it need not indicate
ownership.
Aggregation is a specific form of association in which one class, the whole, contains a collection of other
classes, the parts; here, however, the lifecycle of the parts does not depend upon the whole. For example,
a library and books show aggregation, since books may exist somewhere apart from the library.
In contrast, composition is a stronger form of aggregation that means ownership and lifecycle
dependence; if the whole gets destroyed, then the parts no longer exist. For composition, a good example
would be a house and its different rooms; a room cannot exist without a house.
Association
Association is the cardinal concept in object-oriented programming that describes the relationship
between two independent classes. Association can be viewed as describing a “uses-a” relationship where
an object uses, or in any way interacts with, another object. Association may be either unidirectional or
bidirectional and may exist in several forms, such as one-to-one, one-to-many, many-to-one, and many-to-
many.
Type of Association
Unidirectional Association:
This association is the one in which one class is aware and associated with another class; the reverse is not
true. For example, the Student class can be associated with the LibraryCard class, for the association
where the student has a library card; a LibraryCard does not need to ‘know about’ a Student.
Bidirectional Association:
In this type of association, the classes are aware of each other and interact with one another. For example,
a Teacher class and a Classroom class may be associated bidirectionally; there would be a teacher
assigned to a classroom, and a classroom would know to which teacher it is assigned.
Association Example:
Java
// Java Program to illustrate the
// Concept of Association
// Importing required classes
import java.io.*;
import java.util.*;
// Class 1
// Bank class
class Bank {
// Attributes of bank
private String bankName;
private Set<Employee> employees;
// Class 2
// Employee class
class Employee {
// Attributes of employee
private String name;
// Class 3
// Association between both the
// classes in main method
class AssociationExample {
Output
Ridhi belongs to bank ICICI
Vijay belongs to bank ICICI
Explanation of the above Program:
In the above example, two separate classes Bank and Employee are associated through their Objects.
Bank can have many employees, So, it is a one-to-many relationship.
Aggregation
Aggregation is a relationship that comes under object-oriented programming, classifying an instance of a
class as “has a.” It’s a form of association with weaker relationship strength, whereby the lifetime of the
contained object (part) is not controlled based on the lifetime of the container object (whole). Concepts of
aggregation are quite important for developing modular and reusable software components.
Aggregation is a type of association that represents a relationship where one class is a collection or
container of another class. It depicts a “has-a” relationship, where the container object can exist
independently of its contents, and the contained objects can exist independently of the container.
It is a special form of Association where:
It represents Has-A’s relationship.
It is a unidirectional association i.e. a one-way relationship. For example, a department can have
students but vice versa is not possible and thus unidirectional in nature.
In Aggregation, both entries can survive individually which means ending one entity will not affect
the other entity.
Aggregation Example:
Java
// Java program to illustrate
// Concept of Aggregation
// Class 1
// Student class
class Student {
// Attributes of Student
private String studentName;
private int studentId;
// Class 2
// Department class
// Department class contains list of Students
class Department {
// Class 3
// Institute class
// Institute class contains the list of Departments
class Institute {
// Attributes of Institute
private String instituteName;
private List<Department> departments;
// Class 4
// main class
class AggregationExample {
Output
Total students in institute: 4
Explanation of the above Program:
In this example,
There is an Institute which has no. of departments like CSE, EE. Every department has no. of students.
So, we make an Institute class that has a reference to Object or no. of Objects (i.e. List of Objects) of
the Department class.
That means Institute class is associated with Department class through its Object(s).
And Department class has also a reference to Object or Objects (i.e. List of Objects) of the Student
class means it is associated with the Student class through its Object(s).
It represents a Has-A relationship. In the above example: Student Has-A name. Student Has-A ID.
Department Has-A Students as depicted from the below media.
Composition
Composition is a core concept in object-oriented programming that refers to the relationship “part-of”
between classes. It is a stronger form of association in which the contained objects’ lifecycle is strongly
associated with the container object’s lifecycle. The understanding of composition is crucial in the design
of complex systems where objects of the system are composed of other objects.
Composition is a type of association meaning one class “contains” another. This association can be said
to be a “part-of” relationship and would denote that the contained object is strongly connected with the
containing object, the whole. The parts cannot be without the whole.
Composition is a restricted form of Aggregation in which two entities are highly dependent on each
other.
It represents part-of relationship.
In composition, both entities are dependent on each other.
When there is a composition between two entities, the composed object cannot exist without the other
entity.
Composition Example:
Java
// Java program to illustrate
// Concept of Composition
// Class 1
// Department class
class Department {
// Attributes of Department
public String departmentName;
// Class 2
// Company class
class Company {
// Method
// to add new Department to the Company
public void addDepartment(Department department)
{
departments.add(department);
}
// Method
// to get total number of Departments in the Company
public int getTotalDepartments()
{
return departments.size();
}
}
// Class 3
// Main class
class CompositonExample {
techCompany.addDepartment(new Department("Engineering"));
techCompany.addDepartment(new Department("Operations"));
techCompany.addDepartment(new Department("Human Resources"));
techCompany.addDepartment(new Department("Finance"));
int d = techCompany.getTotalDepartments();
System.out.println("Total Departments: " + d);
System.out.println("Department names: ");
for (Department dept : techCompany.getDepartments()) {
System.out.println("- " + dept.getDepartmentName());
}
}
}
Output
Total Departments: 4
Department names:
- Engineering
- Operations
- Human Resources
- Finance
Explanation of the above Program:
In the above example,
A company can have no. of departments.
All the departments are part-of the Company.
So, if the Company gets destroyed then all the Departments within that particular Company will be
destroyed, i.e. Departments can not exist independently without the Company.
That’s why it is composition. Department is Part-of Company.
A stronger form of
General relationship A special form of association
association with a “part-of”
between two classes with a “has-a” relationship
Definition relationship
One-to-one, one-to-many,
One-to-one, one-to-many,
many-to-one, many-to- One-to-one, one-to-many
many-to-one, many-to-many
Cardinality many
Example Teacher and Student Library and Books Car and Engine
Feature Association Aggregation Composition