Java - 聚合

Java 聚合

聚合是两个类之间的关系，其中一个类包含另一个类的实例。例如，当对象 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。一个学生可以有一个地址。因此，我们在 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 创建一个单独的类，我们不必将属于 Speed 的所有代码都放在 Van 类中，这使得可以在多个应用程序中重用 Speed 类。

在面向对象特性中，用户不需要关心哪个对象正在执行实际工作。为了实现这一点，Van 类向 Van 类的用户隐藏了实现细节。因此，基本上发生的情况是，用户会要求 Van 类执行某个操作，而 Van 类会自己执行该操作，或者要求另一个类执行该操作。