关联,聚合和组合有什么区别？

Question

关联,聚合和组合有什么区别？请解释一下实施情况.

Answer 1

对于两个对象,Foo并且Bar关系可以定义

协会 - 我与一个对象有关系. Foo使用Bar

public class Foo { 
    void Baz(Bar bar) {
    } 
};

作文 - 我拥有一个对象,我对它的生命负责.当Foo死,所以不Bar

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

聚合 - 我有一个我从别人那里借来的东西.当Foo死,Bar可能活下去.

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

Answer 2

我知道这个问题被标记为C#,但概念是非常通用的问题,如此重定向.所以我将在这里提供我的观点(从Java的角度来看有点偏向于我更舒服).

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

聚合和组合是关联的子集,意味着它们是关联的特定情况.

• 在一个类的聚合和组合对象中"拥有"另一个类的对象.
• 但是有一个微妙的区别.在Composition中,由其拥有的类的对象拥有的类的对象不能独立存在(也称为"死亡关系").它将始终作为其拥有对象的一部分存在,而在聚合中,依赖对象是独立的,即使拥有类的对象已经死亡也可以存在.
• 因此,在组合中,如果拥有对象是垃圾收集的,则拥有的对象也将不是聚合中的情况.

困惑？

组成示例:考虑汽车和发动机的示例,该汽车和发动机非常特定于该汽车(意味着它不能用于任何其他汽车).Car和SpecificEngine类之间的这种关系称为组合.没有SpecialEngine类的对象,Car类的对象不能存在,而没有Car类,SpecificEngine的对象没有意义.简单来说,Car class只"拥有"SpecificEngine类.

聚合示例:现在考虑类Car和类Wheel.汽车需要Wheel对象才能运行.含义Car对象拥有Wheel对象但我们不能说没有Car Object对象没有意义.它可以很好地用于自行车,卡车或不同的汽车对象.

总结一下 -

总而言之,关联是一个非常通用的术语,用于表示何时在课堂上使用其他课程提供的功能.如果一个父类对象拥有另一个子类对象,并且该子类对象在没有父类对象的情况下无法有意义地存在,我们就说它是组合.如果它可以,那么它被称为聚合.

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

Answer 3

关联是概括关系的概念.它包括组合和聚合.

合成(混合)是一种将简单对象或数据类型包装到单个单元中的方法.组合是许多基本数据结构的关键组成部分

聚合(集合)与普通组合的不同之处在于它并不意味着所有权.在组合中,当拥有对象被破坏时,包含的对象也被破坏.在汇总中,这不一定是真的.

两者都表示物体之间的关系,只是它们的强度不同.

诀窍要记住差异:有A - A ggregation和O wn - c O mpositoin

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

比喻:

构图:以下图片是图像合成,即使用制作一个图像的单个图像.

聚合:在单个位置收集图像

例如, A大学拥有各个部门,每个部门都有一些教授.如果大学关闭,部门将不复存在,但这些部门的教授将继续存在.因此,大学可以被视为一个部门的组合,而部门则有教授的集合.此外,教授可以在多个部门工作,但一个部门不能成为一个以上大学的一部分.

Answer 4

依赖(引用)
这意味着两个对象之间没有概念链接.例如,EnrollmentService对象引用Student&Course对象(作为方法参数或返回类型)

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

关联(has-a)
这意味着对象之间几乎总是存在链接(它们是关联的).Order对象具有 Customer对象

public class Order {
    private Customer customer
}

聚合(has-a + whole-part)
两种对象之间存在整体关系的特殊关联.但他们可能没有彼此生活.

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

注意:最棘手的部分是区分聚合和正常关联.老实说,我认为这是不同的解释.

组合(具有-a +整体+所有权)
特殊类型的聚合.An Apartment由一些Rooms 组成.一个Room不能没有一个存在Apartment.删除公寓时,所有关联的房间也会被删除.

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

Answer 5

来自Robert Martin在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
};

Answer 6

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

从实现的角度来看,通过引用具有类成员来获得聚合.例如,如果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;
    }
};

重要的一点是,在组合中,容器对象拥有包含的容器对象,而在聚合中,它引用它.

Answer 7

令人惊讶的是,关于三种关系概念关联,聚合和组合之间的区别存在多少混淆.

请注意,聚合和组合这些术语已经在C++社区中使用,可能已经有一段时间了,因为它们已被定义为UML类图中的特殊关联案例.

主要问题是广泛且持续的误解(即使在专家软件开发人员中),构成的概念意味着整体与其部分之间的生命周期依赖性,使得部分在没有整体的情况下不能存在,而忽略了也存在的事实.与不可共享部分的部分整体关联的情况,其中部分可以从整体中分离并在其中消失.

据我所知,这种混乱有两个根源:

1. 在C++社区中,术语"聚合"在定义用于引用另一个独立类的对象的属性的类的意义上使用(参见,例如,[1]),这是UML类图中的关联感.术语"组合"用于为其对象定义组件对象的类,这样在销毁复合对象时,这些组件对象也会被销毁.

2. 在UML类图中,"聚合"和"组合"都被定义为表示部分 - 整体关系的关联的特殊情况(已经在哲学中讨论了很长时间).在他们的定义中,"聚合"和"组合"之间的区别是基于这样的事实:如果它允许在两个或更多个整体之间共享一部分.他们将"组合"定义为具有不可共享(独占)部分,而"聚合"可以共享其部分.此外,他们会说出以下内容:经常,但并非在所有情况下,组合在整体与其各部分之间存在生命周期依赖性,使得部分在没有整体的情况下不能存在.

因此,虽然UML已将术语"聚合"和"组合"放在正确的上下文(部分 - 整体关系)中,但他们还没有设法以清晰明确的方式定义它们,从而捕获开发人员的直觉.但是,这并不奇怪,因为这些关系可能有很多不同的属性(和实现细微差别),开发人员不会就如何实现它们进行协商.

另见我对2009年4月SO问题的扩展答案.

假设在C++社区中定义OOP对象之间的"组合"的属性(并且这个信念仍被广泛持有):两个相关对象(复合及其组件)之间的运行时生命周期依赖性,是并不是"组合"的特征,因为在其他类型的关联中,由于引用完整性,我们也可以具有这种依赖性.

例如,在SO答案中提出了以下"组合"的代码模式:

final class Car {    
  private final Engine engine;

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

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

被访者声称,"组合"的特征是没有其他类可以参考/了解该组件.然而,对于所有可能的"组合"案例来说,这当然不是真的.特别是,在汽车发动机的情况下,可能在另一级别的帮助下实施的汽车制造商可能必须参考发动机,以便在发生问题时能够联系汽车的所有者.

[1] http://www.learncpp.com/cpp-tutorial/103-aggregation/

附录 - StackOverflow上有关组合与聚合的重复问题的不完整列表

[ 2009年4月 ]
聚合与构成 [主要以意见为基础]
[ 2009年4月 ]
作文与协会关系有何区别？ [ 2009年5月 ]
关联,聚合和组合之间的差异
[ 2009年5月 ]
组合和聚合之间有什么区别？[重复]
[ 2009年10月 ]
聚合,组合和依赖之间有什么区别？[标记为重复]
[ 2010年11月 ]
关联与聚合 [标记为重复]
[ 2012年8月 ]
Java中聚合与组合的实现差异
[ 2015年2月 ]
UML - 关联或聚合(简单代码片段)

Answer 8

协会

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

例如:

1. 单向

客户下订单

2. 双向

A与B结婚

B与A结婚

聚合

聚合是一种关联.但具有特定的特征.聚合是一个较大的"整体"类中的关系包含一个或多个较小的"部分"类.相反,较小的"部分"类是"整体"较大类的一部分. .

例如:

俱乐部有会员

俱乐部("整体")由几个俱乐部成员("部分")组成.会员在俱乐部外面有生命.如果俱乐部("整体")死亡,成员("部分")将不会死亡.因为会员可以属于多个俱乐部("整体").

组成

这是一种更强大的聚合形式."整体"负责创建或破坏其"部分"

例如:

学校有部门

在这种情况下,学校("整体")将死亡,部门("部分")将死于此.因为每个部分只能属于一个"整体".

Answer 9

重要的是要理解为什么我们甚至不应该使用不止一次的关系线.最明显的原因是描述类之间的父子关系(当父删除它的所有子项时因此而被删除),但更重要的是,我们想要区分简单的关联和组合,以便对可见性和将变化传播到相关类,这一点在理解和降低系统复杂性方面起着重要作用.

协会

描述类之间静态关系的最抽象方式是使用Association链接,它简单地指出在两个或更多类之间存在某种链接或依赖关系.

弱协会

ClassA可以链接到ClassB,以显示其中一个方法包含ClassB实例的参数,或者返回ClassB的实例.

强大的协会

ClassA也可以链接到ClassB,以表明它拥有对ClassB实例的引用.

聚合(共享关联)

如果ClassA(整个)和ClassB(部分)之间存在部分关系,我们可以更具体,使用聚合链接而不是关联链接,突出显示ClassB也可以由应用程序中的其他类聚合(因此聚合也称为共享关联).

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

聚合与关联 关联链接可以在每种情况下替换聚合链接,而聚合不能在类之间只有"弱链接"的情况下替换关联,即ClassA具有包含ClassB参数的方法,但ClassA不包含保持对ClassB实例的引用.

Martin Fowler建议不应该使用聚合链接,因为它没有附加价值而且会影响一致性,引用Jim Rumbaugh"将其视为建模安慰剂".

作文(非共享协会)

除了ClassA和ClassB之间的部分关系之外,我们应该更具体并使用组合链接 - 两者之间存在强烈的生命周期依赖关系,这意味着当ClassA被删除时,ClassB也会被删除

组合链接显示类(容器,整体)对其他类(部分)具有独占所有权,这意味着容器对象及其部分构成父子关系.

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

测量系统复杂性

通过查看UML类图并评估关联,聚合和组合关系线,可以简单地测量系统复杂性.衡量复杂性的方法是确定通过更改特定类可以影响多少个类.如果类A公开了类B,那么任何使用类A的给定类理论上都会受到类B更改的影响.系统中每个类的可能受影响类的数量总和就是系统的总体复杂性.

您可以在我的博客上阅读更多内容:http: //aviadezra.blogspot.com/2009/05/uml-association-aggregation-composition.html

Answer 10

关联、聚合、组合

Association、Aggregation、Composition是关于有关系的。

Aggregation和Composition是Association 更准确地描述关系的子集

Aggregation-独立关系。对象可以通过构造函数、方法、setter 在类中传递和保存。

Composition-依赖关系。对象是由所有者对象创建的

*关联是 sybtyping 的替代方法

Answer 11

组成(如果删除"整体","部分"也会自动删除 - "所有权")

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

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

• 如果组合类自动处理负责创建/销毁子类的分配/释放,则可以使用指针值.

用C++编写的

#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 --------------------

Answer 12

这些答案的问题在于它们只是故事的一半:它们解释了聚合和组合是关联的形式,但它们没有说明关联是否可能不是那些.

我根据SO上的许多帖子和一些UML文档的一些简要读物收集,有4种主要的类关联形式:

1. 组成:A由A组成; 没有A就不存在B,就像家里的房间一样
2. 聚合:A有一个B; B可以在没有A的情况下存在,就像教室里的学生一样
3. 依赖:A使用-a B; A和B之间没有生命周期依赖关系,如方法调用参数,返回值或方法调用期间创建的临时值
4. 概括:A是-a B.

当两个实体之间的关系不是其中之一时,它可以在术语的一般意义上被称为"关联",并进一步描述其他方式(注意,刻板印象等).

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

• 什么时候关系的具体细节仍在制定中; 图中的这种关系应尽快转换为实际/将要的(其中4个).
• 当一个关系与UML预定的那些关系不匹配时; "通用"关联仍然为您提供了一种表示"不是其他关系"的关系的方式,这样您就不会因使用错误的关系而陷入困境"这实际上不是聚合,而是UML没有我们可以使用的任何其他符号"

Answer 13

我认为此链接将为您做功课：http : //ootips.org/uml-hasa.html

为了理解这些术语，我记得在编程的初期就有一个例子：

如果你有一个包含“盒子”的对象是“棋盘”对象组成，因为如果“棋盘”被删除，没有理由对已经不复存在的框。

如果您有一个带有“颜色”对象的“正方形”对象，并且该正方形被删除，则“颜色”对象可能仍然存在，即聚合

他们都是协会，主要区别是概念

Answer 14

合成：在这里，一旦销毁一个对象（学校），绑定到该对象的另一个对象（教室）也将被销毁。他们两个不能独立存在。

聚合：这与上述（Composition）关联完全相反，在该关联中，一旦杀死一个对象（Company），Employees绑定到该对象的另一个对象（）就可以独立存在。

协会。
组合和聚合是关联的两种形式。

Answer 15

用一个非常简单的句子来说：
聚合和组合是关联的子集。

• A 使用 B -> 这是一个聚合

• A 需要 B -> 是组合。

在这里阅读更多内容。

Answer 16

    Simple rules:
    A "owns" B = Composition : B has no meaning or purpose in the system 
    without A
    A "uses" B = Aggregation : B exists independently (conceptually) from A
    A "belongs/Have" B= Association; And B exists just have a relation
    Example 1:

    A Company is an aggregation of Employees.
    A Company is a composition of Accounts. When a Company ceases to do 
    business its Accounts cease to exist but its People continue to exist. 
    Employees have association relationship with each other.

    Example 2: (very simplified)
    A Text Editor owns a Buffer (composition). A Text Editor uses a File 
    (aggregation). When the Text Editor is closed,
    the Buffer is destroyed but the File itself is not destroyed.

Answer 17

关联是两个独立类之间的关系，关联可以是任何类型，例如一对一、一对多等。它连接两个完全独立的实体。

\n\n

聚合是一种特殊形式的关联，它是类（或实体）之间的单向单向关系，例如钱包和货币类。钱包有钱，但钱\xe2\x80\x99不一定需要有钱包，所以它是一种单向关系。在这种关系中，如果另一个条目结束，两个条目都可以继续存在。在我们的示例中，如果 Wallet 类不存在，并不意味着 Money 类不能存在。

\n\n

组合是聚合的一种受限形式，其中两个实体（或者可以说类）彼此高度依赖。例如人类和心脏。人需要心脏才能生存，心脏需要人体才能生存。换句话说，当类（实体）相互依赖并且它们的寿命相同时（如果一个类（实体）死亡，那么另一个类也会死亡），那么它就是一个组合。如果人类类别不存在，心脏类别就没有意义。

\n

Answer 18

https://www.linkedin.com/pulse/types-relationships-object-oriented-programming-oop-sarah-el-dawody/

组合：是一种“部分”关系。

例如“发动机是汽车的一部分”，“心脏是身体的一部分”。

关联：是一种“has-a”类型的关系

例如，假设我们有两个类，那么如果这两个实体在某些工作中共享彼此的对象，并且同时它们可以在没有彼此依赖的情况下存在，或者两者都有它们的自己的一生。

上面的例子显示了一个关联关系，因为 Employee 和 Manager 类使用彼此的对象，并且都有自己独立的生命周期。

聚合：基于“has-a”关系，它是\\一种特殊的关联形式

例如，“学生”和“地址”。每个学生都必须有一个地址，因此 Student 类和 Address 类之间的关系将是“Has-A”类型的关系，反之亦然。