Java中聚合与组合的区别

17 Mar 2025 | 6 分钟阅读

对象是现实世界中的一个实体，在编程或现实生活中，对象之间存在着相互关系。对象之间通过一种或多种关系相互关联，例如聚合、组合、关联等。

在深入了解这三种关系之前，让我们先来理解聚合和组合之间的区别。

组合 (Composition)

组合是一种“属于”类型的关系，其中一个对象与其他对象在逻辑上相关。它也被称为“has-a”（拥有）关系。我们可以使用以下示例来理解“has-a”或“belong-to”：

教室属于学校，或者说学校有一个教室。所以，称呼它们两者都取决于观点。

组合是一种更强的“has-a”关系，因为包含对象是它的所有者。因此，对象是紧密耦合的，这意味着如果我们删除父对象，子对象也会随之被删除。

让我们举一个例子来理解如何在Java中实现组合关系的逻辑。

CompositionExample.java

import java.util.*;   
// create class for Office
class Office {   
    // declare variables for name and address
	public String name;   
    public String address;   
    // initialize name and address variables using constructor
    Office(String name, String address)   
    {   
        this.name = name;   
        this.address = address;   
    }   
}   
// Create a class for Company that has more than one Office.   
class Company {   
	// declare variable for company name
	public String name;
    // declare a list of OfficeOffice that a Company has 
    private final List< Office Office> offices;
    // initialize variable and list using constructor
    Company(String name, List<Office> offices)  
    {  
    	this.name = name;
        this.offices = offices;  
    }   
    // create a getter function to return a list of office 
    public List<Office> getTotalOfficesOfCompany()   
    {   
        return offices;   
    }   
}   
// create class CompositionExample1 to understand Composition example
class CompositionExample {   
	// main() method start
    	public static void main(String[] args)   
    	{   
        		// create objects of Office class.   
       	 	Office o1 = new Office("Google India Pvt. Ltd", "Banglore");   
       		Office o2 = new Office("Google India Pvt. Ltd", "Gurgaon");
        		Office o3 = new Office("Google India Pvt. Ltd", "Hyderabad");
        		Office o4 = new Office("Google India Pvt. Ltd", "Mumbai");
        		// create list which contains the no. of offices   
        		List<Office> offices = new ArrayList<Office>();   
        		offices.add(o1);   
        		offices.add(o2);   
        		offices.add(o3); 
        		offices.add(o4); 
       		 // create an instance of the Company class by passing a list of Office to the constructor
        		Company company = new Company("Google", offices);   
        		System.out.println(company.name+" offices:");
       		 // get total offices of the Company using getter
        		List<Office> data = company.getTotalOfficesOfCompany();
        		// iterate offices of the company 
        		for (Office office : data) {   
        			// print data 
            			System.out.println("Name : " + office.name + " and "+ " Address : " + office.address);  
        		}   
    	}   
}

输出

聚合 (Aggregation)

聚合关系也是一种“has-a”关系。聚合和组合之间唯一的区别是，在聚合中，对象不是紧密耦合的，或者不涉及所有权。所有对象都是相互独立的，即使父对象被删除，它们也可以继续存在。让我们通过以下示例来理解这一点。

汽车配备有轮子，如果我们拆下它的轮子，轮子仍然会存在。但一辆没有轮子的汽车不像有轮子的汽车那么有用，这就是这种关系最初存在的目的，即将零件组装成一个能够执行比单个零件更多功能的更大的结构。

让我们举一个例子来理解如何在Java中实现聚合关系的逻辑。

Address.java

// create class Address that have fields street, city, state, zip, and country
public class Address {  
	String city,state,country, zip, street;  
	// initialize Address using constructor
	public Address(String street, String city, String state, String zip, String country) {  
		this.city = city;  
		this.state = state;  
		this.country = country;
		this.street = street;  
		this.zip = zip;  
	}  
}

AggregationExample.java

// create AggregationExample class to understand Aggregation concept
public class AggregationExample {  
	// declare variables
	int empId;  
	String empName;  
	Address empAddress;  
	
	// initialize variables using constructor
	public AggregationExample(int empId, String empName, Address empAddress) {  
		this.empId = empId;  
		this.empName = empName;  
    	this.empAddress = empAddress;  
	}  
	// create display() method for showing data
	void display(){  
		System.out.println("Employee Id: "+empId);
		System.out.println("Employee Name: "+empName);  
		System.out.println("Address: "+empAddress.street+""+empAddress.city+" "+empAddress.state+" "+empAddress.zip+" "+empAddress.country);  
	}  
	// main() method start
	public static void main(String[] args) { 
		// create objects of Address class
		Address add1 = new Address("15205 North Kierland Blvd. Suite 100","Scottsdale","AZ", "85254", "America");  
		Address add2 = new Address("2829 Ala Kalanikaumaka, Kukui'ula Village", "Koloa","HI", "96756", "America");  
		
		// create object of AggregationExample by passing value to the constructor
		AggregationExample employee1 = new AggregationExample(001, "Lucy", add1);  
		AggregationExample employee2 = new AggregationExample(002, "Paul", add2);  
		// show data to the users
		employee1.display();  
		employee2.display();  
      
	}  

输出

关联 (Association)

关联不是“has-a”关系，是所有关系中最弱的一种。在关联关系中，没有任何对象是另一个对象的一部分或成员。母子关系是关联的一个简单例子。

让我们举一个例子来理解如何在Java中实现关联关系的逻辑。

AssociationExample.java

import java.util.*;   
// create class Car a Person can have 
class Car {    
	// declare variables for Car brand, color and modal
	public String name, color, modal;  
	// getter and setter for initializing variables
	public String getName() {  
		return name;  
	} 
	public String getColor() {  
		return color;  
	} 
	public String getModal() {  
		return modal;  
	} 
	public void setName(String name) {  
		this.name = name;  
	}
	public void setColor(String color) {  
		this.color = color;  
	}
	public void setModal(String modal) {  
		this.modal = modal;  
	}
}  
// create Person class
class Person {       
	// declare variables for Person class
	public String name;  
	List<Car> cars;
	// getter and setter for initializing variables
	public void showName() {  
		System.out.println(this.name+" has following cars:");
	}  	
	public void setName(String name) {  
		this.name = name;  
	}  
	public void showCars() {  
		for(Car car : cars) {
			System.out.println(car.name+" "+car.modal+" "+car.color);
		}
	}  
	public void setCars(List<Car> cars) {  
		this.cars = cars;  
	}  
}  
// Main class
public class AssociationExample {  
    // main() method start 
	public static void main(String[] args) {  
        // create an object of Person class   
		Person person = new Person();  
		person.setName("Paul");  
		// create objects of Car class
		Car car1 = new Car();  
        car1.setName("Ford BRONCO OUTER BANKS SUV"); 
        car1.setColor("Black");
        car1.setModal("2021");
        Car car2 = new Car();  
        car2.setName("HONDA ODYSSEY EX-L MINIVAN");
        car2.setColor("Brown");
        car2.setModal("2019");
        // create a list of Car
        List<Car> carList = new ArrayList<Car>();  
        carList.add(car1);  
        carList.add(car2);  
        person.setCars(carList);  
        // print details of Person
        person.showName();
        person.showCars();
	}   
}  

输出

聚合与组合的区别

让我们来理解聚合与组合的区别。

序号	聚合 (Aggregation)	组合 (Composition)
1.	定义“has-a”关系的两个对象之间的关联称为聚合。	聚合的一种特定类型，表示所有权，称为组合。
2.	在聚合中，对象可以独立存在于系统范围之外。	在组合关系中，对象不能独立于彼此存在于系统范围之外。
3.	在聚合中，关联的对象是相互独立的。	在组合中，对象是紧密耦合的或相互依赖的。
4.	在聚合中，如果我们删除父对象，子对象仍然存在于系统中。例如，如果我们从汽车上取下轮子，汽车可以用另一个轮子正常运行。	在组合中，如果我们删除父对象，子对象也会被删除。例如，如果我们删除一个文件夹，其中包含的文件也会被删除。
5.	我们用实心菱形表示。	我们用空心菱形表示。
6.	在聚合中，子对象的生命周期不独立。	在组合中，子对象的生命周期是独立的。
7.	在聚合中，如果我们删除一个组件，它不会影响其零件。	在拥有一个类的实例时，它会影响包含类对象。

下一个主题Java中的Morris中序遍历

← 上一个下一个 →

Java中聚合与组合的区别

组合 (Composition)

聚合 (Aggregation)

关联 (Association)

聚合与组合的区别

联系信息

关注我们

教程

面试题

在线编译器

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中聚合与组合的区别

组合 (Composition)

聚合 (Aggregation)

关联 (Association)

聚合与组合的区别

相关帖子

对象引用的相等性

Different Ways to Print Exception Message in Java

Java 中的 init() 方法

Java 中 ChoiceFormat equals() 方法及示例

strictfp keyword in Java

How to Encrypt Password in Java

ElasticSearch Java API

Job Sequencing Problem in Java

如何在 Java 中检查日期是否相等

Java 技术列表

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器