Trong bài này ta sẽ đi tìm hiểu các mối quan hệ dùng trong phân tích thiết kế hệ thống, phân biệt các quan hệ liên kết (Association), hợp thành (Composition), kết tập (Aggregation) và lấy các ví dụ cụ thể trong Java

Liên kết (Association)

Liên kết (Association) là mối quan hệ giữa hai lớp riêng biệt được thiết lập thông qua các Đối tượng của chúng. Liên kết có thể là một-một, một-nhiều, nhiều-một, nhiều-nhiều.
Trong lập trình hướng đối tượng, một đối tượng giao tiếp với các đối tượng khác để sử dụng chức năng và dịch vụ được cung cấp bởi đối tượng đó. Hợp thành (Conposition) và kết tập (Aggregation) là hai hình thức liên kết.

// Java program to illustrate the  
// concept of Association 
import java.io.*; 
  
// class bank 
class Bank  
{ 
    private String name; 
      
    // bank name 
    Bank(String name) 
    { 
        this.name = name; 
    } 
      
    public String getBankName() 
    { 
        return this.name; 
    } 
}  
  
// employee class  
class Employee 
{ 
    private String name; 
      
    // employee name  
    Employee(String name)  
    { 
        this.name = name; 
    } 
      
    public String getEmployeeName() 
    { 
        return this.name; 
    }  
} 
  
// Association between both the  
// classes in main method 
class Association  
{ 
    public static void main (String[] args)  
    { 
        Bank bank = new Bank("Axis"); 
        Employee emp = new Employee("Neha"); 
          
        System.out.println(emp.getEmployeeName() +  
               " is employee of " + bank.getBankName()); 
    } 
} 

Đầu ra:

Neha is employee of Axis

Trong ví dụ trên, hai lớp riêng biệt Bank (Ngân hàng) và Emplyee (Nhân viên) được liên kết thông qua Đối tượng của nó. Ngân hàng có thể có nhiều nhân viên, vì vậy đó là mối quan hệ một-nhiều.

Kết tập (Aggregation)

Kết tập là một dạng đặc biệt của Asociation trong đó:

• Kết tập đại diện cho mối quan hệ Has-A (có một).
• Kết tập là unidirectinal association tức là mối quan hệ một chiều. 

Ví dụ, khoa có thể có sinh viên nhưng ngược lại (sinh viên có thể có khoa) là không thể và do đó về bản chất là một hướng.

• Trong kết tập, cả hai thực thể có thể tồn tại riêng lẻ , điều đó có nghĩa là kết thúc một thực thể sẽ không ảnh hưởng đến thực thể khác

// Java program to illustrate 
//the concept of Aggregation. 
import java.io.*; 
import java.util.*; 
  
// student class 
class Student  
{ 
    String name; 
    int id ; 
    String dept; 
      
    Student(String name, int id, String dept)  
    { 
          
        this.name = name; 
        this.id = id; 
        this.dept = dept; 
          
    } 
} 
  
/* Department class contains list of student 
Objects. It is associated with student 
class through its Object(s). */
class Department  
{ 
      
    String name; 
    private List<Student> students; 
    Department(String name, List<Student> students)  
    { 
          
        this.name = name; 
        this.students = students; 
          
    } 
      
    public List<Student> getStudents()  
    { 
        return students; 
    } 
} 
  
/* Institute class contains list of Department 
Objects. It is asoociated with Department 
class through its Object(s).*/
class Institute  
{ 
      
    String instituteName; 
    private List<Department> departments; 
      
    Institute(String instituteName, List<Department> departments) 
    { 
        this.instituteName = instituteName; 
        this.departments = departments; 
    } 
      
    // count total students of all departments 
    // in a given institute  
    public int getTotalStudentsInInstitute() 
    { 
        int noOfStudents = 0; 
        List<Student> students;  
        for(Department dept : departments) 
        { 
            students = dept.getStudents(); 
            for(Student s : students) 
            { 
                noOfStudents++; 
            } 
        } 
        return noOfStudents; 
    } 
      
}  
  
// main method 
class GFG 
{ 
    public static void main (String[] args)  
    { 
        Student s1 = new Student("Mia", 1, "CSE"); 
        Student s2 = new Student("Priya", 2, "CSE"); 
        Student s3 = new Student("John", 1, "EE"); 
        Student s4 = new Student("Rahul", 2, "EE"); 
      
        // making a List of  
        // CSE Students. 
        List <Student> cse_students = new ArrayList<Student>(); 
        cse_students.add(s1); 
        cse_students.add(s2); 
          
        // making a List of  
        // EE Students 
        List <Student> ee_students = new ArrayList<Student>(); 
        ee_students.add(s3); 
        ee_students.add(s4); 
          
        Department CSE = new Department("CSE", cse_students); 
        Department EE = new Department("EE", ee_students); 
          
        List <Department> departments = new ArrayList<Department>(); 
        departments.add(CSE); 
        departments.add(EE); 
          
        // creating an instance of Institute. 
        Institute institute = new Institute("BITS", departments); 
          
        System.out.print("Total students in institute: "); 
        System.out.print(institute.getTotalStudentsInInstitute()); 
    } 
} 

Đầu ra:

Total students in institute: 4

Nó đại diện cho mối quan hệ Has-A .

Khi nào chúng ta sử dụng Kết tập (Aggregation) ??
Tái sử dụng code được thực hiện tốt nhất bằng kết tập.

Hợp thành (Composition)

Hợp thành (Composition) là một trường hợp đặc biệt của Kết tập (Aggregation) trong đó hai thực thể phụ thuộc nhiều vào nhau.

• Hợp thành đại diện cho quan hệ part -of (là một phần).
• Trong hợp thành, cả hai thực thể đều phụ thuộc vào nhau.
• Khi có một mối quan hệ hợp thành giữa hai thực thể, đối tượng composed không thể tồn tại mà không có thực thể khác.

Ví dụ:

// Java program to illustrate  
// the concept of Composition 
import java.io.*; 
import java.util.*; 
  
// class book 
class Book  
{ 
  
    public String title; 
    public String author; 
      
    Book(String title, String author) 
    { 
          
        this.title = title; 
        this.author = author; 
    } 
} 
  
// Libary class contains  
// list of books. 
class Library  
{ 
  
    // reference to refer to list of books. 
    private final List<Book> books; 
      
    Library (List<Book> books) 
    { 
        this.books = books;  
    } 
      
    public List<Book> getTotalBooksInLibrary(){ 
          
       return books;   
    } 
      
} 
  
// main method 
class GFG  
{ 
    public static void main (String[] args)  
    { 
          
        // Creating the Objects of Book class. 
        Book b1 = new Book("EffectiveJ Java", "Joshua Bloch"); 
        Book b2 = new Book("Thinking in Java", "Bruce Eckel"); 
        Book b3 = new Book("Java: The Complete Reference", "Herbert Schildt"); 
          
        // Creating the list which contains the  
        // no. of books. 
        List<Book> books = new ArrayList<Book>(); 
        books.add(b1); 
        books.add(b2); 
        books.add(b3); 
          
        Library library = new Library(books); 
          
        List<Book> bks = library.getTotalBooksInLibrary(); 
        for(Book bk : bks){ 
              
            System.out.println("Title : " + bk.title + " and " 
            +" Author : " + bk.author); 
        } 
    } 
} 

Đầu ra:

Title : EffectiveJ Java and  Author : Joshua Bloch
Title : Thinking in Java and  Author : Bruce Eckel
Title : Java: The Complete Reference and  Author : Herbert Schildt

Nếu Library (Thư viện) bị hủy thì tất cả sách trong thư viện đó sẽ bị hủy. tức là cuốn sách không thể tồn tại mà không có thư viện. Vì vậy ta nói library (thư viện) được hợp thành từ books (sách)

Kết tập (Aggregation) vs Hợp thành (Composition)

1. Sự phụ thuộc: 

• Kết tập ngụ ý một mối quan hệ trong con có thể tồn tại độc lập với cha mẹ. 

Ví dụ: Ngân hàng và Nhân viên, xóa Ngân hàng thì Nhân viên vẫn tồn tại. 

• Hợp thành ngụ ý một mối quan hệ trong đó con không thể tồn tại độc lập với cha mẹ. 

Ví dụ: Con người và trái tim, trái tim không tồn tại tách biệt với con người. Con người chết thì trái tim cũng chết

2. Kiểu của mối quan hệ: quan hệ Kết tập là “has-a” còn quan hệ Hợp thành là “part-of”
3. Loại liên kết: Hợp thành là một Liên kết mạnh trong khi Kết tập là một Liên kết yếu .

// Java program to illustrate the 
// difference between Aggregation 
// Composition. 
  
import java.io.*; 
  
// Engine class which will  
// be used by car. so 'Car' 
// class will have a field  
// of Engine type. 
class Engine  
{ 
    // starting an engine. 
    public void work() 
    { 
          
        System.out.println("Engine of car has been started "); 
          
    } 
      
} 
  
// Engine class 
final class Car  
{ 
      
    // For a car to move,  
    // it need to have a engine. 
    private final Engine engine; // Composition 
    //private Engine engine;     // Aggregation 
      
    Car(Engine engine) 
    { 
        this.engine = engine; 
    } 
      
    // car start moving by starting engine 
    public void move()  
    { 
          
        //if(engine != null) 
        { 
            engine.work(); 
            System.out.println("Car is moving "); 
        } 
    } 
} 
  
class GFG  
{ 
    public static void main (String[] args)  
    { 
          
        // making an engine by creating  
        // an instance of Engine class. 
        Engine engine = new Engine(); 
          
        // Making a car with engine. 
        // so we are passing a engine  
        // instance as an argument while 
        // creating instace of Car. 
        Car car = new Car(engine); 
        car.move(); 
          
    } 
} 

Đầu ra:

Engine of car has been started 
Car is moving 

Trong trường hợp tổng hợp, Xe thực hiện các chức năng của mình thông qua Động cơ nhưng Động cơ không phải lúc nào cũng là một phần bên trong của Xe. Một động cơ có thể được hoán đổi hoặc thậm chí có thể được gỡ bỏ khỏi xe. 

=> Quan hệ hợp thành (đó là lý do tại sao trường Engine không phải là final).