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

Posted 2023-02-18

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了关联，聚合和组合有什么区别？相关的知识，希望对你有一定的参考价值。

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

答案

对于两个对象，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;

另一答案

组成（如果删除“整体”，“部分”也会自动删除 - “所有权”）

在新类中创建现有类的对象。这称为组合，因为新类由现有类的对象组成。
通常使用普通成员变量。
如果组合类自动处理负责创建/销毁子类的分配/释放，则可以使用指针值。

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

另一答案

我认为这个链接会做你的功课：http://ootips.org/uml-hasa.html

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

如果你有一个'棋盘'对象，其中包含'box'对象，这是因为如果'棋盘'被删除，那么盒子就没有理由存在了。

如果你有一个'square'对象有一个'color'对象并且方块被删除，'color'对象可能仍然存在，那就是聚合

它们都是联想，主要区别在于概念

另一答案

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

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