关联、聚合和组合之间的区别是什么?

我认为这个链接将完成你的功课:http://ootips.org/uml-hasa.html

为了理解这些术语，我记得我早期编程时的一个例子:

如果你有一个“chess board”对象，其中包含“box”对象，则为作文，因为如果“chess board”被删除，那么盒子就没有理由再存在了。

如果你有一个'square'对象，它有一个'color'对象，正方形被删除了，'color'对象可能仍然存在，即聚合

它们都是协会，主要的区别是概念上的

正如其他人所说，关联是对象之间的关系，聚合和组合是关联的类型。

从实现的角度来看，聚合是通过类成员通过引用获得的。例如，如果类A聚合类B的一个对象，你会有这样的东西(在c++中):

class A {
B & element;
// or B * element;
};

聚合的语义是，当对象A被销毁时，它所存储的对象B仍然存在。当使用组合时，你有一个更强的关系，通常通过存储成员的价值:

class A {
B element;
};

在这里，当一个A对象被销毁时，它所包含的B对象也将被销毁。最简单的方法是按值存储成员，但你也可以使用智能指针，或在析构函数中删除成员:

class A {
std::auto_ptr<B> element;
};


class A {
B * element;


~A() {
delete B;
}
};

重要的一点是，在组合中，容器对象拥有是被包含的对象，而在聚合中，它参考文献是它。

来自罗伯特·马丁在comp.object的帖子:

关联表示一个实例向另一个实例发送消息的能力。这通常是通过指针或引用实例变量实现的，尽管它也可以实现为一个方法参数，或创建一个局部变量。

//[Example:]


//|A|----------->|B|


class A
{
private:
B* itsB;
};

聚合[…是典型的整体/部分关系。这与实例不能具有循环聚合关系(即部分不能包含其整体)的异常关联完全相同。

//[Example:]


//|Node|<>-------->|Node|


class Node
{
private:
vector<Node*> itsNodes;
};

这是聚合的事实意味着Node的实例不能形成一个循环。因此，这是一个节点树，而不是节点图。

成分[…和聚合完全一样，只是“部分”的生命周期由“整体”控制。这种控制可以是直接的，也可以是传递的。也就是说，“整体”可以直接负责创造或破坏“部分”，或者它可以接受一个已经创建的部分，然后将它传递给其他某个整体，由其承担责任。

//[Example:]


//|Car|<#>-------->|Carburetor|


class Car
{
public:
virtual ~Car() {delete itsCarb;}
private:
Carburetor* itsCarb
};

对于Foo和Bar这两个对象，可以定义关系

协会 -我和一个对象有关系。Foo使用Bar

public class Foo {
private Bar bar;
};

注意:请参阅福勒的定义 -关键是Bar在语义上与Foo相关，而不仅仅是依赖关系(如int或string)。

我拥有一个对象，我对它的生命周期负责。当Foo死亡时，Bar也会死亡

public class Foo {
private Bar bar = new Bar();
}

我有一个对象，我从别人那里借来的。当Foo死亡时，Bar可能会继续存在。

public class Foo {
private Bar bar;
Foo(Bar bar) {
this.bar = bar;
}
}

我知道这个问题被标记为c#，但概念是相当通用的像这样的问题重定向这里。所以我将在这里提供我的观点(从java的角度来看，我更舒服)。

当我们想到面向对象的本质时，我们总是想到对象、类(对象蓝图)以及它们之间的关系。对象之间通过方法相互关联和交互。换句话说，一个类的对象可以使用另一个类的对象提供的服务/方法。这种关系被称为协会。。

聚合和组合是关联的子集意味着它们是特定的关联案例。

• 在聚合和组合一个类的对象“拥有”另一个类的对象。
• 但是有一个微妙的区别。在作文中，由其所属类不能独自生活的对象拥有的类的对象(也称为“死亡关系”)。它将始终作为其所属对象的一部分存在，而在聚合中，依赖对象是独立的，即使所属类的对象已经死亡，它也可以存在。
• 因此在组合中，如果拥有的对象被垃圾收集，那么拥有的对象也会被垃圾收集，而在聚合中则不是这样。

困惑吗?

作文的例子:以一辆汽车为例，它的发动机是这辆汽车特有的(这意味着它不能用于任何其他汽车)。车和SpecificEngine类之间的这种关系称为组合。Car类的对象如果没有SpecificEngine类的对象就不能存在，而如果没有Car类，SpecificEngine的对象就没有意义。简单地说，Car类单独“拥有”SpecificEngine类。

聚合的例子:现在考虑类车和类轮。Car需要一个Wheel对象来运行。这意味着Car对象拥有Wheel对象，但我们不能说没有Car对象，Wheel对象就没有意义。它可以很好地用于自行车，卡车或不同的汽车对象。

# EYZ0

总而言之，关联是一个非常通用的术语，用于表示一个类使用另一个类提供的功能。如果一个父类对象拥有另一个子类对象，并且没有父类对象，这个子类对象就不能有意义地存在，我们就说它是复合。如果可以，则称为聚合。

更多细节在这里。 我是http://opensourceforgeeks.blogspot.in的作者，并添加了上面相关帖子的链接以获取更多上下文

协会是关系的广义概念。它包括组合和聚合。

作文(混合物)是一种将简单对象或数据类型包装到单一的单位中的方法。组合是许多基本数据结构的关键构建块

聚合(若干事物形成一个集群)不同于普通的组合，因为它并不意味着所有权。在组合中，当拥有的对象被销毁时，包含的对象也被销毁。总的来说，这并不一定正确。

# EYZ0:

• “有——# EYZ0": # EYZ0ggregation
• “# EYZ0art - # EYZ1f": com # EYZ2sitoin
• “# EYZ0s-a": # EYZ0nheritance

现在让我们观察下面的图像

类比:

聚合:单个位置的图像集合

一所大学有不同的系，每个系都有一些教授。如果大学关闭，这些部门将不复存在，但这些部门的教授将继续存在。因此，一所大学可以被看作是一个系的组成部分，而系则是教授的集合。此外，教授可以在一个以上的部门工作，但一个部门不能属于一所以上的大学。

依赖(引用)
这意味着两个物体之间没有概念上的联系。例如:registrmentservice对象引用Student &课程对象(作为方法参数或返回类型)

public class EnrollmentService {
public void enroll(Student s, Course c){}
}

协会 (has-a)
这意味着对象之间几乎总是有一个链接(它们是相关联的)。 订单对象< em >有一个< / em >客户对象

public class Order {
private Customer customer
}

聚合 (has-a + whole-part)
两个对象之间存在整体-部分关系的一种特殊联想。但是他们可能没有彼此而活

public class PlayList {
private List<Song> songs;
}

或

public class Computer {
private Monitor monitor;
}

最棘手的部分是区分聚合和普通关联。老实说，我认为这有不同的解释。

作文 (has-a +全部-部分+所有权)
一种特殊的聚合。Apartment由一些# eyz1组成。没有Apartment， Room就不可能存在。当一个公寓被删除时，所有相关的房间也会被删除

public class Apartment{
private Room bedroom;
public Apartment() {
bedroom = new Room();
}
}

协会， 聚合和作文这三个关系概念之间的区别令人惊讶。

注意术语聚合和作文已经在c++社区中使用了，可能在它们被定义为UML类图中协会的特殊情况之前已经有一段时间了。

主要的问题是广泛的和持续的误解(甚至在专家软件开发人员中)，组合的概念意味着整体和它的部分之间的生命周期依赖关系，以至于部分不能没有整体而存在，忽略了这样一个事实，即也存在与不可共享部分的部分-整体-关联的情况，其中部分可以从整体中分离出来，并且在整体被破坏后仍然存在。

在我看来，这种困惑有两个根源:

1. 在c++社区中，术语“聚合”的含义是一个类定义了一个属性，用于引用另一个独立类的对象(参见，例如[1])，这是UML类图中的关联的含义。术语“组合”用于为其对象定义组件对象的类，这样在组合对象被销毁时，这些组件对象也被销毁。

2. 在UML类图中，“聚合”和“组合”都被定义为表示part-whole关系的特殊情况(这在哲学中已经讨论了很长时间)。在他们的定义中，“聚合”和“组合”之间的区别是基于它是否允许在两个或多个整体之间共享一部分。他们将“组合”定义为具有不可共享(独占)的部分，而“聚合”可以共享它们的部分。此外，他们还说了一些类似于以下的话:通常情况下，但不是所有情况下，组合在整体和部分之间具有生命周期依赖关系，这样，如果没有整体，部分就无法存在。

因此，尽管UML将术语“聚合”和“组合”放在了正确的上下文中(部分-整体关系)，但是他们并没有设法以一种清晰和明确的方式来定义它们，从而捕捉开发人员的直觉。然而，这并不奇怪，因为这些关系可以有很多不同的属性(和实现的细微差别)，开发人员对如何实现它们没有一致的意见。

请参见下面列出的我的详细回答到2009年4月SO问题。

c++社区中定义OOP对象之间“组合”的属性(这个信念仍然被广泛持有):两个相关对象(组合及其组件)之间的运行时生命周期依赖关系并不是“组合”的真正特征，因为在其他类型的关联中，我们也可以由于引用完整性而具有这种依赖关系。

例如，下面的“composition”代码模式在SO回答中被提出:

final class Car {
private final Engine engine;


Car(EngineSpecs specs) {
engine = new Engine(specs);
}


void move() {
engine.work();
}
}

被调查者声称这是“合成”的特征，没有其他类可以引用/知道这个组件。然而，并非所有可能的“组合”情况都是如此。特别是，在汽车引擎的情况下，汽车的制造商(可能是在另一个类的帮助下实现的)可能必须引用引擎，以便在出现问题时能够联系汽车的所有者。

[1] # EYZ0

附录-关于StackOverflow上的组合与聚合的反复询问问题的不完整列表

< >强协会< / >强

关联表示两个类之间的关系。它可以是单向的(单向)或双向的(双向)

例如:

1. 单向

客户下单

2. 双向

A和B结婚了

B和A结婚了

< >强聚合< / >强

聚合是一种关联。但是有特定的特征。聚合是一个更大的“整体”的关系。类包含一个或多个较小的“部分”;类。相反，较小的“部分”;阶级是“整体”的一部分。大的类。

例如:

俱乐部有会员

一个俱乐部(“整体”)是由几个俱乐部成员(“部分”)组成的。会员可以在俱乐部外生活。如果这个俱乐部(“整体”)死了，它的成员(“部分”)不会随之而死。因为会员可以属于多个俱乐部(“全部”)。

< >强作文< / >强

这是一种更强的聚合形式。负责创建或销毁其“部分”;

例如:

学校有院系

这些答案的问题在于，它们只说了一半:它们解释了聚合和组合是关联的形式，但没有说一个关联是否可能不是这两种形式。

基于对SO和一些UML文档的一些简要阅读，我收集到类关联有4种主要的具体形式:

1. A是由A组成的;没有A, B就不存在，就像家里的房间一样
2. 聚合:A有A B;B可以没有A而存在，就像教室里的学生一样
3. 依赖:A使用B;A和B之间没有生命周期依赖关系，比如方法调用参数、返回值或方法调用期间创建的临时对象
4. 泛化:A是A

当两个实体之间的关系不是其中之一时，它可以被称为一般意义上的“关联”，并以其他方式进一步描述(注意，原型等)。

我的猜测是，“通用关联”主要用于两种情况:

• 当一段关系的细节还没有确定的时候;图中的这种关系应该尽快转换成它实际是什么/将是什么(其他4种关系之一)。
• 当一个关系不匹配UML预先确定的这4个中的任何一个时;“通用的”关联仍然给了你一种表示“不是其他关系之一”的关系的方法，这样你就不会被一个错误的关系所困，并注意到“这实际上不是聚合，只是UML没有任何其他我们可以使用的符号”。

重要的是要理解为什么我们应该使用不止一次的关系线。最明显的原因是描述类之间的父子关系(当父类删除其所有子类时，所有子类也会被删除)，但更无能为力的是，我们想要区分简单的关联和组合，以便对相关类的更改的可见性和传播施加隐式限制，这在理解和减少系统复杂性中起着重要作用。

协会

描述类之间静态关系的最抽象的方法是使用Association链接，它简单地说明两个或多个类之间存在某种类型的链接或依赖关系。

弱协会

类a可以链接到类b，以显示其方法之一包含类b实例的参数，或返回类b实例。

强大的协会

类a也可以被链接到类b，以显示它持有对类b实例的引用。

聚合(共享关联)

在类a(整体)和类b(部分)之间存在部分关系的情况下，我们可以更具体地使用聚合链接而不是关联链接，强调类b也可以由应用程序中的其他类聚合(因此聚合也称为共享关联)。

需要注意的是，聚合链接并没有以任何方式说明ClassA拥有ClassB，也没有说明两者之间存在父子关系(当父类删除其所有子类时，其结果也将被删除)。事实上，恰恰相反!聚合链接通常用于强调ClassA不是ClassB的独占容器，因为实际上ClassB有另一个容器。

聚合vs关联 关联链接在任何情况下都可以取代聚合链接，而聚合不能在类之间只有“弱链接”的情况下取代关联，例如ClassA有包含ClassB参数的方法/s，但ClassA不包含对ClassB实例的引用

马丁·福勒认为聚合链接根本不应该使用，因为它没有附加价值，而且会扰乱一致性，引用吉姆·拉姆博的话:“把它看作建模安慰剂”。

组合(非共享关联)

我们应该更具体地使用复合链接，在这种情况下，除了类a和类b之间的部分关系之外——两者之间有很强的生命周期依赖关系，这意味着当类a被删除时，ClassB也会被删除

复合链接表明一个类(容器，整体)对其他类(部分)具有独占所有权，这意味着容器对象及其部分构成了父子关系。

与关联和聚合不同，在使用组合关系时，组合类不能作为组合类的返回类型或参数类型出现。因此，对组合类的更改不能传播到系统的其余部分。因此，随着系统的增长，组合的使用限制了复杂性的增长。

测量系统复杂性

系统复杂性可以简单地通过查看UML类图并评估关联、聚合和组合关系行来测量。度量复杂性的方法是确定有多少类可以通过更改一个特定的类而受到影响。如果类A暴露了类B，那么任何使用类A的给定类理论上都可能受到类B变化的影响。系统中每个类可能受到影响的类的数量之和就是系统的总复杂性。

我想说明如何在Rails中实现这三个术语。ActiveRecord将两个模型之间的任何类型的关系称为association。在阅读与ActiveRecord相关的文档或文章时，人们不会经常发现术语composition和aggregation。通过向类的主体中添加一个关联类宏来创建关联。其中一些宏是belongs_to， has_one， has_many等。

如果我们想要设置一个composition或aggregation，我们需要将belongs_to添加到拥有的模型(也称为子模型)，并将has_one或has_many添加到拥有的模型(也称为父模型)。我们设置composition还是aggregation取决于我们在子模型中传递给belongs_to调用的选项。在Rails 5之前，在没有任何选项的情况下设置belongs_to会创建一个aggregation，子进程可以在没有父进程的情况下存在。如果我们想要一个composition，我们需要通过添加选项aggregation1显式声明:

class Room < ActiveRecord::Base
belongs_to :house, required: true
end

在Rails 5中，这一点被改变了。现在，声明belongs_to关联会默认创建composition，如果没有父关联，子关联就不能存在。所以上面的例子可以重写为:

class Room < ApplicationRecord
belongs_to :house
end

如果我们想要允许子对象在没有父对象的情况下存在，我们需要通过选项optional显式地声明这一点

class Product < ApplicationRecord
belongs_to :category, optional: true
end

组合(如果你删除“整体”，“部分”也会自动删除-“所有权”)

• 在新类中创建现有类的对象。这称为组合，因为新类是由现有类的对象组成的。

• 通常使用普通成员变量。

• 如果组合类自动处理负责创建/销毁子类的分配/回收，则可以使用指针值。

# EYZ0

#include <iostream>
using namespace std;
/********************** Engine Class ******************/
class Engine
{
int nEngineNumber;
public:
Engine(int nEngineNo);
~Engine(void);
};
Engine::Engine(int nEngineNo)
{
cout<<" Engine :: Constructor " <<endl;
}
Engine::~Engine(void)
{
cout<<" Engine :: Destructor " <<endl;
}
/********************** Car Class ******************/
class Car
{
int nCarColorNumber;
int nCarModelNumber;
Engine objEngine;
public:
Car (int, int,int);
~Car(void);
};
Car::Car(int nModelNo,int nColorNo, int nEngineNo):
nCarModelNumber(nModelNo),nCarColorNumber(nColorNo),objEngine(nEngineNo)
{
cout<<" Car :: Constructor " <<endl;
}
Car::~Car(void)
{
cout<<" Car :: Destructor " <<endl;
Car
Engine
Figure 1 : Composition
}
/********************** Bus Class ******************/
class Bus
{
int nBusColorNumber;
int nBusModelNumber;
Engine* ptrEngine;
public:
Bus(int,int,int);
~Bus(void);
};
Bus::Bus(int nModelNo,int nColorNo, int nEngineNo):
nBusModelNumber(nModelNo),nBusColorNumber(nColorNo)
{
ptrEngine = new Engine(nEngineNo);
cout<<" Bus :: Constructor " <<endl;
}
Bus::~Bus(void)
{
cout<<" Bus :: Destructor " <<endl;
delete ptrEngine;
}
/********************** Main Function ******************/
int main()
{
freopen ("InstallationDump.Log", "w", stdout);
cout<<"--------------- Start Of Program --------------------"<<endl;
// Composition using simple Engine in a car object
{
cout<<"------------- Inside Car Block ------------------"<<endl;
Car objCar (1, 2,3);
}
cout<<"------------- Out of Car Block ------------------"<<endl;
// Composition using pointer of Engine in a Bus object
{
cout<<"------------- Inside Bus Block ------------------"<<endl;
Bus objBus(11, 22,33);
}
cout<<"------------- Out of Bus Block ------------------"<<endl;
cout<<"--------------- End Of Program --------------------"<<endl;
fclose (stdout);
}

输出

--------------- Start Of Program --------------------
------------- Inside Car Block ------------------
Engine :: Constructor
Car :: Constructor
Car :: Destructor
Engine :: Destructor
------------- Out of Car Block ------------------
------------- Inside Bus Block ------------------
Engine :: Constructor
Bus :: Constructor
Bus :: Destructor
Engine :: Destructor
------------- Out of Bus Block ------------------
--------------- End Of Program --------------------

聚合(如果你删除“整体”，“部分”可以存在-“无所有权”)

• 聚合是一种特定类型的组合，其中不暗示复杂对象和子对象之间的所有权。当一个聚合被销毁时，子对象不会被销毁。

• 通常使用指针变量/引用变量指向在聚合类作用域之外的对象

• 可以使用指向在聚合类范围之外的对象的引用值吗

• 不负责创建/销毁子类

c++中的聚合代码

#include <iostream>
#include <string>
using namespace std;
/********************** Teacher Class ******************/
class Teacher
{
private:
string m_strName;
public:
Teacher(string strName);
~Teacher(void);
string GetName();
};
Teacher::Teacher(string strName) : m_strName(strName)
{
cout<<" Teacher :: Constructor --- Teacher Name :: "<<m_strName<<endl;
}
Teacher::~Teacher(void)
{
cout<<" Teacher :: Destructor --- Teacher Name :: "<<m_strName<<endl;
}
string Teacher::GetName()
{
return m_strName;
}
/********************** Department Class ******************/
class Department
{
private:
Teacher *m_pcTeacher;
Teacher& m_refTeacher;
public:
Department(Teacher *pcTeacher, Teacher& objTeacher);
~Department(void);
};
Department::Department(Teacher *pcTeacher, Teacher& objTeacher)
: m_pcTeacher(pcTeacher), m_refTeacher(objTeacher)
{
cout<<" Department :: Constructor " <<endl;
}
Department::~Department(void)
{
cout<<" Department :: Destructor " <<endl;
}
/********************** Main Function ******************/
int main()
{
freopen ("InstallationDump.Log", "w", stdout);
cout<<"--------------- Start Of Program --------------------"<<endl;
{
// Create a teacher outside the scope of the Department
Teacher objTeacher("Reference Teacher");
Teacher *pTeacher = new Teacher("Pointer Teacher"); // create a teacher
{
cout<<"------------- Inside Block ------------------"<<endl;
// Create a department and use the constructor parameter to pass the teacher to it.
Department cDept(pTeacher,objTeacher);
Department
Teacher
Figure 2: Aggregation
} // cDept goes out of scope here and is destroyed
cout<<"------------- Out of Block ------------------"<<endl;
// pTeacher still exists here because cDept did not destroy it
delete pTeacher;
}
cout<<"--------------- End Of Program --------------------"<<endl;
fclose (stdout);
}

输出

--------------- Start Of Program --------------------
Teacher :: Constructor --- Teacher Name :: Reference Teacher
Teacher :: Constructor --- Teacher Name :: Pointer Teacher
------------- Inside Block ------------------
Department :: Constructor
Department :: Destructor
------------- Out of Block ------------------
Teacher :: Destructor --- Teacher Name :: Pointer Teacher
Teacher :: Destructor --- Teacher Name :: Reference Teacher
--------------- End Of Program --------------------