Association in Java

Association in Java defines the connection between two classes that are set up through their objects. Association manages one-to-one, one-to-many, and many-to-many relationships. In Java, the multiplicity between objects is defined by the Association. It shows how objects communicate with each other and how they use the functionality and services provided by that communicated object. Association manages one-to-one, one-to-many, many-to-one and many-to-many relationships.

Let's take an example of each relationship to manage by the Association.

A person can have only one passport. It defines the one-to-one
If we talk about the Association between a College and Student, a College can have many students. It defines the one-to-many
A state can have several cities, and those cities are related to that single state. It defines the many-to-one
A single student can associate with multiple teachers, and multiple students can also be associated with a single teacher. Both are created or deleted independently, so it defines the many-to-many

Let's takes an example of an Association to understand how it works in Java.

AssociationExample.java

import java.util.*; 
 class Mobile {  
    private String mobile_no;
  
    public String getMobileNo() {
        return mobile_no;
    }
    public void setMobileNo(String mobile_no) {
        this.mobile_no = mobile_no;
    }
}
class Person {     
    private String name;
    List<Mobile> numbers;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Mobile> getNumbers() {
        return numbers;
    }
    public void setNumbers(List<Mobile> numbers) {
        this.numbers = numbers;
    }
}
public class AssociationExample {
      public static void main(String[] args) {
            Person person = new Person();
            person.setName("Shubham Rastogi");
           
           Mobile number1 = new Mobile();
            number1.setMobileNo("8868923136");
            Mobile number2 = new Mobile();
            number2.setMobileNo("8630023310");
    
            List<Mobile> numberList = new ArrayList<Mobile>();
            numberList.add(number1);
            numberList.add(number2);
            person.setNumbers(numberList);
            System.out.println(person.getNumbers()+" are mobile numbers of the person "+
            person.getName());
        }
      
 }

Output:

Description

In the above example, we create two separate classes, i.e., Person and Mobile, associated through their objects. A person can have many mobile numbers, so it defines the one-to-many relationship.

Types of Association

In Java, two types of Association are possible:

IS-A Association
HAS-A Association
1. Aggregation
2. Composition

1) IS-A Association

The IS-A Association is also referred to as Inheritance. We all know about Inheritance in Java and if you don't know about it, click here.

2) HAS-A Association

The HAS-A Association is further classified into two parts, i.e., Aggregation and Composition. Let's understand the difference between both of them one by one.

1) Aggregation

In Java, the Aggregation association defines the HAS-A relationship. Aggregation follows the one-to-one or one-way relationship. If two entities are in the aggregation composition, and one entity fails due to some error, it will not affect the other entity.

Let's take the example of a toy and its battery. The battery belongs to a toy, and if the toy breaks and deletes from our database, the battery will still remaining in our database, and it may still be working. So in Aggregation, objects always have their own lifecycles when the ownership exists there.

AggregationExample

import java.util.*; 
  
// Student class 
class Student  
{ 
    String name; 
    int enrol ; 
    String course; 
      
    Student(String name, int enrol, String course)  
    { 
          
        this.name = name; 
        this.enrol = enrol; 
        this.course = course; 
    } 
} 
  
// Course class having a list of students.
class course  
{ 
    
    String name; 
    private List<Student> students; 
    Course(String name, List<Student> students)  
    { 
          
        this.name = name; 
        this.students = students; 
          
    } 
      
    public List<Student> studentsData()  
    { 
        return students; 
    } 
} 
  
/* College class having a list of Courses*/
class College
{ 
      
    String collegeName; 
    private List<Course> courses; 
      
    College(String collegeName, List<Course> courses) 
    { 
        this.collegeName = collegeName; 
        this.courses = courses; 
    } 
      
    // Returning number of students available in all courses in a given college  
    public int countStudents() 
    { 
        int studentsInCollege = 0; 
        List<Student> students;  
        for(Course course : courses) 
        { 
            students = course.studentsData(); 
            for(Student s : students) 
            { 
                studentsInCollege++; 
            } 
        } 
        return studentsInCollege; 
    } 
      
}  
  
// main method 
class AggregationExample
{ 
    public static void main (String[] args)  
    { 
        Student std1 = new Student("Emma", 1801, "MCA"); 
        Student std2 = new Student("Adele", 1802, "BSC-CS"); 
        Student std3 = new Student("Aria", 1803, "Poly"); 
        Student std4 = new Student("Ally", 1804, "MCA"); 
        Student std5 = new Student("Paul", 1805, "Poly");       
        
        // Constructing list of MCA Students. 
        List <Student> mca_students = new ArrayList<Student>(); 
        mca_students.add(std1); 
        mca_students.add(std4); 
          
        //Constructing list of BSC-CS Students. 
        List <Student> bsc_cs_students = new ArrayList<Student>(); 
        bsc_cs_students.add(std2); 
		
        //Constructing list of Poly Students. 
        List <Student> poly_students = new ArrayList<Student>(); 
        poly_students.add(std3); 
        poly_students.add(std5); 
          
        Course MCA = new Course("MCA", mca_students); 
        Course BSC_CS = new Course("BSC-CS", bsc_cs_students);
        Course Poly = new Course("Poly", poly_students); 
          
        List <Course> courses = new ArrayList<Course>(); 
        courses.add(MCA); 
        courses.add(BSC_CS);
        courses.add(Poly); 
          
        // creating object of College. 
        College college = new College("ABES", courses); 
        
        System.out.print("Total number of students in the college "+ college.collegeName +" is "+ college.countStudents());
    } 
}

Output:

Description:

In the above example, there is a college that has several courses like BSC-CS, MCA, and Poly. Every course has several students, so we make a College class that has a reference to the object or list of objects of the Course class. That means College class is associated with Course class through the objects. Course class also has a reference to the object or list of objects of Student class means it is associated with Student class through its object and defines the HAS-A relationship.

2) Composition

A restricted form of the Aggregation where the entities are strongly dependent on each other. Unlike Aggregation, Composition represents the part-of relationship. When there is an aggregation between two entities, the aggregate object can exist without the other entity, but in the case of Composition, the composed object can't exist. To learn more about Composition, click here.

Let's take an example to understand the concept of Composition.

We create a class Mobile that contains variables, i.e., name, ram and rom. We also create a class MobileStore that has a reference to refer to the list of mobiles. A mobile store can have more than one mobile. So, if a mobile store is destroyed, then all mobiles within that particular mobile store will also be destroyed because mobiles cannot exist without a mobile store. The relationship between the mobile store and mobiles is Composition.

CompositionExample.java:

import java.util.*;
class Mobile
{
  public String name;
  public String ram;
  public String rom;
  Mobile(String Name, String ram, String rom
  {
    this.name = name;
    this.ram = ram;
	this.rom = rom;
  }
}
class MobileStore
{
  private final List<Mobile> mobiles;
  MobileStore (List<Mobile> mobiles)
  {
    this.mobiles = mobiles;
  }
  public List<Mobile> getTotalMobileInStore(){
    return mobiles;
  }
}
public class CompositionExample {
  public static void main (String[] args)
  {
    Mobile mob1 = new Mobile("Realme6","8GB", "128GB");
    Mobile mob2 = new Mobile("SAMSUNG A21S", "4GB", "128");
    Mobile mob3 = new Mobile("SAMSUNG M10", "4GB", "64GB");
    List<Mobile> mobiles = new ArrayList<Mobile>();
    mobiles.add(mob1);
    mobiles.add(mob2);
    mobiles.add(mob3);
    MobileStore store = new MobileStore(mobiles);
    List<Mobile> mob = store.getTotalMobileInStore();
    for(Mobile mb : mob){
      System.out.println("Name : " + mb.name + " RAM :" +mb.ram + " and "
          +" ROM : " + mb.rom);
    }
  }
}

Output: