关联

关联是通过对象建立的, 两个单独类之间的关系。关联可以是一对一，一对多，多对一，多对多。
在面向对象的编程中，一个对象与其他对象进行通信以使用该对象提供的功能和服务。组合和聚合是关联的两种形式。

// Java展示关联
import java.io.*;
// class bank
class Bank
{
    private String name;
    // bank名称
    Bank(String name)
    {
        this.name = name;
    }
    public String getBankName()
    {
        return this.name;
    }
}
// employee类
class Employee
{
    private String name;
    // employee名称
    Employee(String name)
    {
        this.name = name;
    }
    public String getEmployeeName()
    {
        return this.name;
    }
}
// 关联两个类
class Association
{
    public static void main (String[] args)
    {
        Bank bank = new Bank("高盛");
        Employee emp = new Employee("小兰");
        System.out.println(emp.getEmployeeName() +
               " 被雇于 " + bank.getBankName());
    }
}

输出：

小兰  被雇于 高盛

在上面的示例中，两个单独的类：Bank和Employee通过其对象关联。银行可以有很多员工，所以这是一对多的关系。

聚合

这是一种特殊的关联形式，其中：

• 它表示Has-A关系。
• 它是单向关联。例如，部门可以有学生，但反之则不可，因此本质上是单向的。
• 在关联中，两个条目均可单独存在，这意味着结束一个实体不会影响另一个实体
  

  // Java展示关联.
  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;
      }
  }
  // 部门类，包含不同学生
  class Department
  {
      String name;
      private List students;
      Department(String name, List students)
      {
          this.name = name;
          this.students = students;
      }
      public List getStudents()
      {
          return students;
      }
  }
  // 学院类，包含不同部门
  class Institute
  {
      String instituteName;
      private List departments;
      Institute(String instituteName, List departments)
      {
          this.instituteName = instituteName;
          this.departments = departments;
      }
      // 计算所有部门中的所有学生
      public int getTotalStudentsInInstitute()
      {
          int noOfStudents = 0;
          List students;
          for(Department dept : departments)
          {
              students = dept.getStudents();
              for(Student s : students)
              {
                  noOfStudents++;
              }
          }
          return noOfStudents;
      }
  }
  // main函数
  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");
          // 制造一个List的学生，专业ces
          List  cse_students = new ArrayList();
          cse_students.add(s1);
          cse_students.add(s2);
          // 制造一个List的学生，专业ee
          List  ee_students = new ArrayList();
          ee_students.add(s3);
          ee_students.add(s4);
          Department CSE = new Department("CSE", cse_students);
          Department EE = new Department("EE", ee_students);
          List  departments = new ArrayList();
          departments.add(CSE);
          departments.add(EE);
          // 创建一个Institute实例
          Institute institute = new Institute("BITS", departments);
          System.out.print("所有系的学生数量: ");
          System.out.print(institute.getTotalStudentsInInstitute());
      }
  }

  输出：

  所有系的学生数量: 4

  在此示例中，我们创建一个Institute类，该类引用了Object或没有学生。部门类的对象(即对象列表)。这意味着学院类通过其对象与部门类相关联。并且部门类还引用了Student类的一个或多个对象(即对象列表)，这意味着它通过其Object与Student类相关联。
  它代表一种Has-A关系。
  
  什么时候使用聚合？
  最好通过聚合来实现代码重用。

组合

组合是聚合的一种受限形式，其中两个实体相互高度依赖。

• 它代表部分关系。
• 在组合上，两个实体相互依赖。
• 当两个实体之间存在组合关系时，没有另一个实体就无法存在组合对象。

让我们以图书馆为例

// Java展示组合
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类，包含书的List
class Library
{
    // 书List.
    private final List books;
    Library (List books)
    {
        this.books = books;
    }
    public List getTotalBooksInLibrary(){
       return books;
    }
}
// main方法
class GFG
{
    public static void main (String[] args)
    {
        // 生成一些列书的Object.
        Book b1 = new Book("芒果文档-Java", "mango");
        Book b2 = new Book("芒果文档-Java变量", "mango boy");
        Book b3 = new Book("芒果文档-Java继承", "mango girl");
        // 创建书的List.
        List books = new ArrayList();
        books.add(b1);
        books.add(b2);
        books.add(b3);
        Library library = new Library(books);
        List bks = library.getTotalBooksInLibrary();
        for(Book bk : bks){
            System.out.println("书名 : " + bk.title + " and "
            +" 作者 : " + bk.author);
        }
    }
}

输出

书名 : 芒果文档-Java : mango
书名 : 芒果文档-Java变量 : mango boy
书名 : 芒果文档-Java继承 : mango girl

在上面的示例中，一个库可以没有。同一主题或不同主题的书籍。因此，如果图书馆被销毁，则该特定图书馆中的所有图书都会被销毁。即书没有图书馆就不可能存在。这就是为什么它是组成。

组合和聚合

1. 依赖关系：聚合意味着一种关系，在该关系中，子类可以独立于父类而存在。例如，银行和雇员，删除银行和雇员仍然存在。而“组合”则意味着孩子不能独立于父母而存在的关系。示例：人与心，心并不与人分开存在
2. 关系类型：聚合关系为“具有”，组合关系为“部分”关系。
3. 关联类型：组成是强关联，而聚集是弱关联。

   // Java代码，展示组合和聚合的关系
   import java.io.*;
   // Engine类
   class Engine
   {
       //  启动引擎.
       public void work()
       {
           System.out.println("车的引擎被启动 ");
       }
   }
   // Engine类
   final class Car
   {
       
       private final Engine engine; // 聚合
       //private Engine engine;     // 组合
       Car(Engine engine)
       {
           this.engine = engine;
       }
       // 开启引擎
       public void move()
       {
           //if(engine != null)
           {
               engine.work();
               System.out.println("车在动 ");
           }
       }
   }
   class GFG
   {
       public static void main (String[] args)
       {
           // 创造engine实例
           Engine engine = new Engine();
   
           Car car = new Car(engine);
           car.move();
       }
   }

   输出：

   车的引擎被启动
   车在动