Java 中的关联 vs. 聚合 vs. 组合

2024 年 9 月 10 日 | 阅读 7 分钟

在面向对象编程 (OOP) 中，将类连接在一起是至关重要的组成部分，它构成了一个复杂的互联网络。Java 引入了支撑这些交互的三种基本概念：**关联 (association)、聚合 (aggregation) 和组合 (composition)**。这些概念不仅是课堂讨论的基础，也是开发灵活且可维护软件的关键。

关联：连接类

在庞大的 Java 世界中，关联是类之间链接的基础。它描述了一对一、一对多或多对多的复杂关系，超越了简单的连接。考虑以下特征来理解关联的细微之处：

关联的特征

1. 多重性 (Multiplicity)

关联定义了一个类的实例与另一个类的实例之间的关系，并且可以采取不同的多重性。这可以是“一对多”或“多对多”，用于更复杂的关系。“一对一”表示单个链接。

2. 方向性 (Directionality)

关联可以是单向的，也可以是双向的。单向关联鼓励单向连接，这意味着一个类知道另一个类。另一方面，双向关联通过表示两个类之间的共享理解来建立双向通信。

3. 导航 (Navigation)

通过方法调用或直接访问属性，必须在类之间进行导航。这种动态交互是构建具有灵活类关系的复杂系统的基础。

Association.java

// Import required libraries
import java.io.*;
import java.util.*;
// Class with name 'Branch' is created
class Branch {
    // Instance variable of the class
    private String name;
    // Parameterized constructor of this class
    Branch(String name) {
        // 'this' keyword is used to refer to the current class
        this.name = name;
    }
    // Method for the class
    public String getBranchName() {
        return this.name;
    }
}
// Class with name 'Student' is created
class Student {
    // Instance variable of the class
    private String name;
    // Parameterized constructor of this class
    Student(String name) {
        // 'this' keyword is used to refer to the current class
        this.name = name;
    }
    // Method of the class
    public String getStudentName() {
        // Returning the name of the student
        return this.name;
    }
}
// Main class
class Association {
    // Main method
    public static void main(String[] args) {
        // Using the Scanner class to read inputs from the user
        // Creating an object for the Scanner class
        Scanner sc = new Scanner(System.in);
        // Asking the user to enter the branch name
        System.out.println("Enter branch name of the student");
        // Storing the string in variable 's'
        String s = sc.nextLine();
        // Asking the user to enter the name of the student
        System.out.println("Enter name of the student ");
        // Storing the string in variable 's2'
        String s2 = sc.nextLine();
        // Object creation for classes
        Branch b = new Branch(s);
        Student std = new Student(s2);
        // Accessing methods of classes using objects created for the classes
        System.out.println(std.getStudentName() + " is a student of " + b.getBranchName());
    }
}

输出

Enter branch name of the student
CSE
Enter name of the student 
RAM
RAM is a student of CSE

聚合：整体-部分关系

一种更复杂的连接类型是聚合，它表示一种“整体-部分”关系，其中实体由独立的部分组成。与关联不同，聚合表示更强的联系，并允许组件独立运行。考虑以下特征来理解聚合交响曲的细微之处：

聚合的特征

1. 所有权 (Ownership)

聚合体现了一种复杂的归属感。“整体”类与“部分”类保持关联，但并不拥有绝对的控制权。不同的整体可以共享部分，从而实现共享和动态交互。

2. 灵活性 (Flexibility)

这种类型的连接提供了适应性。可以轻松添加或删除部分或组件，而不会破坏整体框架。这种灵活性在许多软件设计场景中至关重要。

3. 生命周期 (Lifecycle)

在聚合的领域内，组件的生命周期可能与整体的生命周期分开。它们为设计增加了复杂性，并且可以先于或晚于整个实体创建或销毁而存在。

Car.java

// Engine class representing the "part" in the aggregation
class Engine {
    private String fuelType;
    // Getter and setter for fuelType
    public String getFuelType() {
        return fuelType;
    }
    public void setFuelType(String fuelType) {
        this.fuelType = fuelType;
    }
    // Other Engine attributes and methods
}
// Car class representing the "whole" in the aggregation
public class Car {
    private String model;
    private Engine engine; // Aggregation
    // Getter and setter for model
    public String getModel() {
        return model;
    }
    public void setModel(String model) {
        this.model = model;
    }
    // Getter and setter for engine
    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    // Other Car attributes and methods
    // Method to display information about the car
    public void displayCarInfo() {
        System.out.println("Car Model: " + getModel());
        System.out.println("Engine Fuel Type: " + getEngine().getFuelType());
    }
    // Main method
    public static void main(String[] args) {
        Engine carEngine = new Engine();
        carEngine.setFuelType("Petrol");
        Car myCar = new Car();
        myCar.setModel("Sedan");
        myCar.setEngine(carEngine);
        myCar.displayCarInfo();
    }
}

输出

Car Model: Sedan
Engine Fuel Type: Petrol

组合 (Composition)

在聚合的领域内，组合表现为一种更严格的形式，其中每个元素都完全依赖于整体的存在。由于它们紧密的联系，组成部分和整体一起被创建，最重要的是，一起被销毁。让我们研究一下定义这种相互依赖性的特征：

组合的特征

1. 所有权和生命周期 (Ownership and Lifecycle)

组合引入了一种强烈的归属感。“整体”类负责“部分”类的创建和销毁，同时也拥有它。它们紧密交织的生命周期促进了和谐共生的交互。

2. 责任 (Responsibility)

整体组合负责控制其组成部分的行为和生命周期。这种增强的责任感使得结构更加紧密，相互依赖性更高。

3. 不可变性 (Immutability)

在某些情况下，组合会导致不可变性。实体一旦完全形成，其组成部分就变得不可变，从而加强了结构并防止了更改。

Human.java

// Heart class representing the "part" in the composition
class Heart {
    // Heart attributes and methods
    // Example method for the Heart class
    public void beat() {
        System.out.println("Heart is beating...");
    }
}
// Human class representing the "whole" in the composition
public class Human {
    private String name;
    private Heart heart; // Composition

    // Constructor for the Human class
    public Human(String name) {
        this.name = name;
        this.heart = new Heart();
    }
    // Getter for the name attribute
    public String getName() {
        return name;
    }
    // Getter for the heart attribute
    public Heart getHeart() {
        return heart;
    }
    // Example method for the Human class
    public void walk() {
        System.out.println(getName() + " is walking.");
    }
    // Main method
    public static void main(String[] args) {
        Human person = new Human("Alice");
        // Accessing methods of the Human and Heart classes using objects
        person.walk();
        person.getHeart().beat();
    }
}

输出

Alice is walking.
Heart is beating.

用例

关联 (Association)

当类之间存在通用关系，但所有权或依赖性较小时，使用关联。

聚合 (Aggregation)

当一个类代表另一个类的集合，但每个部分都可以独立存在时，使用聚合。

组合 (Composition)

当组件对整体至关重要且具有紧密联系的生命周期时，使用组合。

特性	关联 (Association)	聚合 (Aggregation)	组合 (Composition)
关系类型	两个或多个类之间的通用关系。	“整体-部分”关系，其中部分可以独立存在。	“整体-部分”关系，具有更强的联系，部分依赖于整体。
依赖级别	较低依赖：类可以独立存在。	中度依赖：部分可以独立于整体存在。	较高依赖；部分与整体一同被销毁。
代码重用性	高：类可以在不同上下文中重用。	中度：部分可以在不同整体中重用。	低：为特定整体设计的特定组件。
灵活性	高：一个类的更改不一定会影响另一个类。	中度：部分的变化可能会影响整体，反之亦然。	低：一个组件的变化可能对整体产生重大影响。
示例	Student 和 Branch 类形成基本关系。	Car 和 Engine 类，其中 Engine 是 Car 的一部分。	Human 和 Heart 类，其中 Heart 是 Human 的一个组成部分。
代码表示	没有特定的关键字，只是不同类的对象在交互。	使用类变量来表示部分和整体。	使用类变量并在构造函数中实例化以创建组合。
代码复杂度	低：类之间的简单关系。	中度：管理部分与整体之间的关系。	高：管理依赖关系并确保正确销毁。

结论

关联 (Association)：它通过表示依赖性较小的类之间的通用关系来促进代码重用性和灵活性。
聚合 (Aggregation)：它表示一种稍有依赖的“整体-部分”关系。部分可以独立运行，并在其他场景中重用。
组合 (Composition)：它创建了一种更依赖、更强的“整体-部分”关系。部分共同销毁的特性创造了更强的联系，但代码重用性较低。

根据特定需求和给定设计中类之间的交互，可以选择关联、聚合和组合。每种方法对于构建可靠且可管理的 Java 面向对象系统都至关重要。

下一主题Java 的协变与逆变

Java 中的关联 vs. 聚合 vs. 组合

关联：连接类

关联的特征

聚合：整体-部分关系

聚合的特征

组合 (Composition)

组合的特征

用例

组合 (Composition)

结论

联系信息

关注我们

教程

面试题

在线编译器

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

Java 中的关联 vs. 聚合 vs. 组合

关联：连接类

关联的特征

聚合：整体-部分关系

聚合的特征

组合 (Composition)

组合的特征

用例

组合 (Composition)

结论

相关帖子

Java 中的溢出和下溢

native Keyword in Java

Java 中的拼写检查器

Java 中的最长连续子序列

Java 程序求最大乘积子数组

Duodecimal in Java

Eclipse Java 快捷键

Java 中构造函数的使用 | Java 中构造函数的目的

CompositeName endsWith() method in Java with Examples

使用 Java 泛型将 Set 转换为 Stream 的程序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器