Association in Java

2025年3月28日 | 阅读 5 分钟

Java 中的关联定义了两个类通过其对象建立的连接。关联管理着一对一、一对多和多对多关系。在 Java 中，对象之间的多重性由关联定义。它显示了对象之间如何通信以及它们如何使用通信对象的提供的功能和服务。关联管理着一对一、一对多、多对一和多对多关系。

让我们举一个关联管理的每种关系的例子。

一个人只能拥有一本护照。这定义了一对一关系。
如果我们谈论学院和学生之间的关联，一个学院可以有很多学生。这定义了一对多关系。
一个州可以有几个城市，而这些城市与同一个州相关。这定义了多对一关系。
一个学生可以与多个老师关联，而多个学生也可以与一个老师关联。两者是独立创建或删除的，因此它定义了多对多关系。

让我们举一个关联的例子来理解它在 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());
        }
      
 }

输出

描述

在上面的示例中，我们创建了两个单独的类，即 Person 和 Mobile，它们通过对象关联。一个人可以有很多手机号码，因此它定义了一对多关系。

关联的类型

在 Java 中，可能存在两种类型的关联：

IS-A 关联
HAS-A 关联
1. 聚合 (Aggregation)
2. 组合 (Composition)

1) IS-A 关联

IS-A 关联也被称为继承。我们都了解 Java 中的继承，如果您不了解，请点击此处。

2) HAS-A 关联

HAS-A 关联进一步分为两个部分，即聚合和组合。让我们一个接一个地理解它们之间的区别。

1) 聚合

在 Java 中，聚合关联定义了HAS-A关系。聚合遵循一对一或单向关系。如果两个实体处于聚合组合中，并且一个实体由于某些错误而失败，它不会影响另一个实体。

让我们以玩具和电池为例。电池属于一个玩具，如果玩具损坏并从我们的数据库中删除，电池仍将保留在我们的数据库中，并且可能仍在工作。因此，在聚合中，当存在所有权时，对象始终具有自己的生命周期。

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());
    } 
}

输出

描述

在上面的示例中，有一个学院拥有 BSC-CS、MCA 和 Poly 等课程。每门课程都有几个学生，因此我们创建了一个 College 类，它具有对 Course 类对象或对象列表的引用。这意味着 College 类通过对象与 Course 类相关。Course 类还具有对 Student 类对象或对象列表的引用，这意味着它通过其对象与 Student 类相关，并定义了HAS-A关系。

2) 组合

聚合的一种受限形式，其中实体高度相互依赖。与聚合不同，组合表示part-of（部分属于）关系。当两个实体之间存在聚合时，聚合对象可以在没有另一个实体的情况下存在，但在组合的情况下，组合对象不能存在。要了解更多关于组合的信息，请点击此处。

让我们举一个例子来理解组合的概念。

我们创建了一个名为 Mobile 的类，它包含变量，即 name、ram 和 rom。我们还创建了一个名为 MobileStore 的类，它有一个引用来引用手机列表。一个手机店可以拥有不止一部手机。因此，如果手机店被销毁，那么该手机店内的所有手机也将被销毁，因为手机不能在没有手机店的情况下存在。手机店和手机之间的关系是组合。

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);
    }
  }
}

输出

下一个主题Image-processing-in-java-face-detection

Association in Java

AssociationExample.java

描述

关联的类型

1) IS-A 关联

2) HAS-A 关联

1) 聚合

2) 组合

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Association in Java

AssociationExample.java

描述

关联的类型

1) IS-A 关联

2) HAS-A 关联

1) 聚合

2) 组合

相关帖子

Java Program to Print All the Leaders in an Array

Queue 的 poll() 和 remove() 方法的区别

Java 中的“是”关系是什么

Java 微服务如何相互通信

Check if a Tree is Isomorphic or Not in Java?

Java 中的 Bitset 类

Java 中的对象切片

Java 中的字母图案

如何在 Java 中动态地向 ArrayList 添加元素

Java vs. Kotlin

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器