我知道聚合和组合之间的概念差异。有人可以通过示例告诉我它们之间在 Java 中的实现差异吗？
【问题讨论】：
标签： java relationship aggregation composition
作曲
final class Car {
private final Engine engine;
Car(EngineSpecs specs) {
engine = new Engine(specs);
}
void move() {
engine.work();
}
}
聚合
final class Car {
private Engine engine;
void setEngine(Engine engine) {
this.engine = engine;
}
void move() {
if (engine != null)
engine.work();
}
}
在组合的情况下，Engine完全被Car封装。外界无法获得对 Engine 的引用。引擎与汽车一起生死存亡。通过聚合，Car 也通过 Engine 执行其功能，但 Engine 并不总是 Car 的内部部分。引擎可能会被交换，甚至完全移除。不仅如此，外界仍然可以对 Engine 有一个引用，并且不管它是否在 Car 中，都可以对其进行修改。
【讨论】：
new Engine(EngineSpecs) 调用创建引擎。实现组合的方法是将Engine创建为一个内部类，这样引擎的对象总是参照一个Car Object来创建
我会使用一个很好的 UML 示例。
以一所拥有 1 到 20 个不同系且每个系有 1 到 5 位教授的大学为例。 大学和它的部门之间有一个组成联系。 一个系和它的教授之间有一个聚合链接。
组合只是一个强大的聚合，如果大学被摧毁，那么部门也应该被摧毁。但我们不应该杀死教授，即使他们各自的部门消失了。
在java中：
public class University {
private List<Department> departments;
public void destroy(){
//it's composition, when I destroy a university I also destroy the departments. they cant live outside my university instance
if(departments!=null)
for(Department d : departments) d.destroy();
departments.clean();
departments = null;
}
}
public class Department {
private List<Professor> professors;
private University university;
Department(University univ){
this.university = univ;
//check here univ not null throw whatever depending on your needs
}
public void destroy(){
//It's aggregation here, we just tell the professor they are fired but they can still keep living
for(Professor p:professors)
p.fire(this);
professors.clean();
professors = null;
}
}
public class Professor {
private String name;
private List<Department> attachedDepartments;
public void destroy(){
}
public void fire(Department d){
attachedDepartments.remove(d);
}
}
围绕这个。
编辑：根据要求提供示例
public class Test
{
public static void main(String[] args)
{
University university = new University();
//the department only exists in the university
Department dep = university.createDepartment();
// the professor exists outside the university
Professor prof = new Professor("Raoul");
System.out.println(university.toString());
System.out.println(prof.toString());
dep.assign(prof);
System.out.println(university.toString());
System.out.println(prof.toString());
dep.destroy();
System.out.println(university.toString());
System.out.println(prof.toString());
}
}
大学课堂
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class University {
private List<Department> departments = new ArrayList<>();
public Department createDepartment() {
final Department dep = new Department(this, "Math");
departments.add(dep);
return dep;
}
public void destroy() {
System.out.println("Destroying university");
//it's composition, when I destroy a university I also destroy the departments. they cant live outside my university instance
if (departments != null)
departments.forEach(Department::destroy);
departments = null;
}
@Override
public String toString() {
return "University{\n" +
"departments=\n" + departments.stream().map(Department::toString).collect(Collectors.joining("\n")) +
"\n}";
}
}
部门类
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Department {
private final String name;
private List<Professor> professors = new ArrayList<>();
private final University university;
public Department(University univ, String name) {
this.university = univ;
this.name = name;
//check here univ not null throw whatever depending on your needs
}
public void assign(Professor p) {
//maybe use a Set here
System.out.println("Department hiring " + p.getName());
professors.add(p);
p.join(this);
}
public void fire(Professor p) {
//maybe use a Set here
System.out.println("Department firing " + p.getName());
professors.remove(p);
p.quit(this);
}
public void destroy() {
//It's aggregation here, we just tell the professor they are fired but they can still keep living
System.out.println("Destroying department");
professors.forEach(professor -> professor.quit(this));
professors = null;
}
@Override
public String toString() {
return professors == null
? "Department " + name + " doesn't exists anymore"
: "Department " + name + "{\n" +
"professors=" + professors.stream().map(Professor::toString).collect(Collectors.joining("\n")) +
"\n}";
}
}
教授班
import java.util.ArrayList;
import java.util.List;
public class Professor {
private final String name;
private final List<Department> attachedDepartments = new ArrayList<>();
public Professor(String name) {
this.name = name;
}
public void destroy() {
}
public void join(Department d) {
attachedDepartments.add(d);
}
public void quit(Department d) {
attachedDepartments.remove(d);
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Professor " + name + " working for " + attachedDepartments.size() + " department(s)\n";
}
}
实施是有争议的，因为它取决于您需要如何处理创建、雇用删除等。与 OP 无关
【讨论】：
一个简单的作曲程序
public class Person {
private double salary;
private String name;
private Birthday bday;
public Person(int y,int m,int d,String name){
bday=new Birthday(y, m, d);
this.name=name;
}
public double getSalary() {
return salary;
}
public String getName() {
return name;
}
public Birthday getBday() {
return bday;
}
///////////////////////////////inner class///////////////////////
private class Birthday{
int year,month,day;
public Birthday(int y,int m,int d){
year=y;
month=m;
day=d;
}
public String toString(){
return String.format("%s-%s-%s", year,month,day);
}
}
//////////////////////////////////////////////////////////////////
}
public class CompositionTst {
public static void main(String[] args) {
// TODO code application logic here
Person person=new Person(2001, 11, 29, "Thilina");
System.out.println("Name : "+person.getName());
System.out.println("Birthday : "+person.getBday());
//The below object cannot be created. A bithday cannot exixts without a Person
//Birthday bday=new Birthday(1988,11,10);
}
}
【讨论】：
简单来说：
组合和聚合都是关联。 组合 -> 强 Has-A 关系 聚合 -> 弱 Has-A 关系。
【讨论】：
下面给出的网址中有一个很好的解释。
http://www.codeproject.com/Articles/330447/Understanding-Association-Aggregation-and-Composit
请检查！！！
【讨论】：
首先我们必须谈谈Aggregation 和Composition 在同一页面上的实际区别。
聚合是一种关联，关联实体可以独立于关联而存在。例如，一个人可能与一个组织相关联，但他/她可能在系统中独立存在。
而
组合是指其中一个关联实体与另一个密切相关并且没有另一个存在就不能存在的情况。事实上，该实体的身份总是与另一个对象的身份相关联。例如，汽车的轮子。
现在，聚合可以简单地通过将一个实体的属性保存在另一个实体中来实现，如下所示：
class Person {
Organisation worksFor;
}
class Organisation {
String name;
}
class Main {
public static void main(String args[]) {
//Create Person object independently
Person p = new Person();
//Create the Organisation independently
Organisation o = new Organisation();
o.name = "XYZ Corporation";
/*
At this point both person and organisation
exist without any association
*/
p.worksFor = o;
}
}
对于组合而言，依赖对象必须始终以其关联对象的身份创建。您也可以使用内部类。
class Car {
class Wheel {
Car associatedWith;
}
}
class Main {
public static void main() {
//Create Car object independently
Car car = new Car();
//Cannot create Wheel instance independently
//need a reference of a Car for the same.
Car.Wheel wheel = car.new Wheel();
}
}
请注意，根据应用场景，相同的用例可能属于聚合/组合。例如，如果您正在为在某个组织中工作的人员开发应用程序，并且必须在注册时引用组织，则人员-组织案例可能会变成组合。同样，如果您要维护汽车零件的库存，则可以聚合 Car-Wheel 关系。
【讨论】：
让我们设定条款。 Aggregation 是 UML 标准中的一个元术语，表示组合和共享聚合，简称为 shared。它经常被错误地命名为“聚合”。这很糟糕，因为组合也是一种聚合。据我了解，您的意思是“共享”。
UML 标准的进一步说明：
composite - 表示属性是复合聚合的， 即，复合对象对存在和 组合对象（部分）的存储。
因此，大学与大教堂协会是一个组合，因为大学不存在大教堂（恕我直言）
共享聚合的精确语义因应用领域和 建模师。
即，如果您只遵循您或其他人的某些原则，则所有其他关联都可以绘制为共享聚合。也看here。
【讨论】：
聚合与组合
聚合意味着孩子可以独立于父母而存在的关系。比如Bank and Employee，删除Bank，Employee仍然存在。
而组合意味着孩子不能独立于父母而存在的关系。示例：人与心，心与人是分不开的。
聚合关系是“has-a”，组合是“part-of”关系。
Composition 是强关联，而 Aggregation 是弱关联。
【讨论】：
这两种类型当然都是关联，并没有真正严格地映射到这样的语言元素。区别在于目的、上下文以及系统的建模方式。
作为一个实际示例，比较具有相似实体的两种不同类型的系统：
主要跟踪汽车及其所有者等的汽车注册系统。这里我们对作为一个单独实体的引擎不感兴趣，但我们可能仍然有与引擎相关的属性，例如功率和燃料类型。这里的引擎可能是汽车实体的复合部分。
汽车维修店管理系统，用于管理汽车零件、维修汽车和更换零件，可能是整个发动机。在这里，我们甚至可能有发动机库存，需要单独跟踪它们和其他部件，并且独立于汽车。在这里，引擎可能是汽车实体的聚合部分。
您如何用您的语言实现这一点是次要问题，因为在那个级别上，诸如可读性之类的事情要重要得多。
【讨论】：