聚合是一种两个类之间的关系，其中一个类包含另一个类的实例。例如，当一个对象 A 包含对另一个对象 B 的引用，或者说对象 A 与对象 B 之间存在 HAS-A 的关系时，这就被称为 Java 编程中的聚合。
Java 聚合的作用
Java 中的聚合有助于代码的复用。对象 B 可以有一些实用方法，这些方法可以被多个对象所利用。任何包含对象 B 的类都可以使用它的方法。
Java 聚合示例
示例 1
在这个例子中，我们创建了几个类，如 Vehicle、Speed。定义了一个 Van 类，它继承自 Vehicle 类，并且包含一个 Speed 类的对象。Van 类继承了 Vehicle 类的属性，而 Speed 作为它的属性，我们通过调用者对象传递给它。在输出中，我们打印了 Van 对象的详细信息。
package com.tutorialspoint;
class Vehicle{
private String vin;
public String getVin() {
return vin;
}
public void setVin(String vin) {
this.vin = vin;
}
}
class Speed{
private double max;
public double getMax() {
return max;
}
public void setMax(double max) {
this.max = max;
}
}
class Van extends Vehicle {
private Speed speed;
public Speed getSpeed() {
return speed;
}
public void setSpeed(Speed speed) {
this.speed = speed;
}
public void print() {
System.out.println("Vin: " +this.getVin() + ", Max Speed: " + speed.getMax() );
}
}
public class Tester {
public static void main(String[] args) {
Speed speed = new Speed();
speed.setMax(120);
Van van = new Van();
van.setVin("abcd1233");
van.setSpeed(speed);
van.print();
}
}
输出：
Vin: abcd1233, Max Speed: 120.0
示例 2
在这个例子中，我们创建了几个类，如 Student、Address。一个学生可以有一个地址，所以我们定义了一个 Address 类的实例变量在 Student 类中。在输出中，我们打印了学生的详细信息。
package com.tutorialspoint;
class Address {
int strNum;
String city;
String state;
String country;
Address(int street, String c, String st, String country) {
this.strNum = street;
this.city = c;
this.state = st;
this.country = country;
}
}
class Student {
int rno;
String stName;
Address stAddr;
Student(int roll, String name, Address address){
this.rno = roll;
this.stName = name;
this.stAddr = address;
}
}
public class Tester {
public static void main(String[] args) {
Address ad= new Address(10, "Bareilly", "UP", "India");
Student st= new Student(1, "Aashi", ad);
System.out.println("Roll no: "+ st.rno);
System.out.println("Name: "+ st.stName);
System.out.println("Street: "+ st.stAddr.strNum);
System.out.println("City: "+ st.stAddr.city);
System.out.println("State: "+ st.stAddr.state);
System.out.println("Country: "+ st.stAddr.country);
}
}
输出：
Roll no: 1
Name: Aashi
Street: 10
City: Bareilly
State: UP
Country: India
在某种意义上，这是一种类型的关联。聚合是一种单向的关系，精确地表达了类之间的 HAS-A 关系。此外，当两个类被聚合时，终止其中一个类不会影响另一个类。相比之下，组合通常是被视为一种强关系，其中父类拥有子类实体，这意味着子实体不能直接访问并且没有父对象就不能存在。相反，在关联中，父实体和子实体都可以独立存在。
HAS-A 关系
这些关系主要基于使用情况。这决定了某个类是否拥有某样东西。这种关系有助于减少代码重复以及潜在的错误。
例如：
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
这表明 Van 类拥有一个 Speed。通过将 Speed 类单独定义，我们不必将所有与速度相关的代码都放在 Van 类内部，这使得 Speed 类可以在多个应用程序中重用。
在面向对象的特性中，用户不需要关心实际执行工作的对象是谁。为了实现这一点，Van 类向 Van 类的用户隐藏了实现细节。因此，基本上发生的情况是用户会要求 Van 类执行某个动作，而 Van 类要么自己完成工作，要么请求另一个类来执行动作。