Quelle est la différence entre l'association, d'agrégation et de composition?

Je sais que cette question est étiqueté comme C#, mais les concepts sont assez génériques des questions de ce genre rediriger ici. Donc, je vais donner mon point de vue ici (un peu biaisée de java point de vue où je suis plus à l'aise).

Quand on pense orientée Objet, la nature on pense toujours à des Objets de la classe (objets bleus) et les relations entre eux. Les objets sont liés et interagissent les uns avec les autres par l'intermédiaire des méthodes. En d'autres termes l'objet d'une classe peut utiliser les services/les méthodes fournies par l'objet d'une autre classe. Ce type de relation est appelée aussi association..

L'agrégation et la Composition sont des sous-ensembles de l'association ce qui signifie qu'ils sont des cas particuliers de l'association.

• Dans l'agrégation et la composition objet d'une classe est "propriétaire" de l'objet de l'autre classe.
• Mais il y a une différence subtile. Dans Composition l'objet de la classe qui est la propriété de l'objet de sa classe possédant ne peut pas vivre sur son propre(Également appelé "la mort de la relation"). Il sera toujours vivre en tant que partie de l'objet propriétaire où, comme dans le Agrégation l'objet dépendant est autonome et peut exister même si l'objet de la possession de classe est morte.
• Donc dans la composition si la possession de l'objet garbage collecté la propriété de l'objet sera également qui n'est pas le cas dans l'agrégation.

Confus?

Exemple de Composition : prenons l'exemple d'une Voiture et un moteur qui est très spécifique à la voiture (ce qui signifie qu'il ne peut pas être utilisé dans n'importe quelle autre voiture). Ce type de relation entre Voiture et SpecificEngine classe est appelée Composition. Un objet de la classe Voiture ne peut pas exister sans un objet de SpecificEngine classe et l'objet de la SpecificEngine n'a pas de signification sans classe de Voiture. À mettre en mots simples Voiture de classe uniquement le "propriétaire" du SpecificEngine classe.

Agrégation Exemple : considérons Maintenant la classe Voiture et de la classe Roue. Voiture a besoin d'une Roue de l'objet à la fonction. Sens la Voiture objet possède la Roue de l'objet, mais on ne peut pas dire que la Roue de l'objet n'a pas de signification de la Voiture sans Objet. Il peut très bien être utilisé sur un Vélo, de Camions ou de Voitures différentes de l'Objet.

En résumé -

Pour résumer, l'association est une très terme générique utilisé pour représenter lorsqu'une classe utilise les fonctionnalités fournies par une autre classe. Nous dire que c'est la composition si l'un des parents de la classe de l'objet possède un autre enfant de la classe de l'objet et que les enfants de la classe de l'objet ne peut véritablement exister sans le parent de la classe de l'objet. Si il peut, puis il est appelé Agrégation.

Plus de détails ici.
Je suis l'auteur de http://opensourceforgeeks.blogspot.in et avons ajouté un lien ci-dessus à la poste pour plus de contexte.

Dépendance (références)

Il n'y a pas de lien conceptuel entre deux objets. par exemple, EnrollmentService les références de l'objet d'Étudiants & objets de Cours (comme les paramètres de la méthode ou des types de retour)

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

Association (a-a)

Il n'y a presque toujours un lien entre les objets (ils sont liés).
Afin d'objet a un Client de l'objet

public class Order {
    private Customer customer
}

Agrégation (a-a + tout-partie)

Genre spécial de l'association, où il y a toute la partie de la relation entre les deux objets. ils pourraient vivre l'un sans l'autre si.

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

Remarque: la partie la plus délicate est à distinguer de l'agrégation de la normale de l'association. Honnêtement, je pense que c'est ouvert à différentes interprétations.

Composition (a-a + pour la pièce entière + de propriété)

Genre spécial de l'agrégation. Un Apartment est composé de quelques Rooms. Un Room ne peut exister sans un Apartment. lorsqu'un appartement est supprimé, tous les associés les chambres sont supprimées.

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

Comme les autres ont dit, une association est une relation entre des objets, l'agrégation et la composition sont des types d'association.

À partir d'une mise en œuvre d'un point de vue de l'agrégation est obtenue par la présence d'un membre de la classe par référence. Par exemple, si la classe A des agrégats d'un objet de la classe B, vous aurez quelque chose comme ceci (en C++):

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

La sémantique de l'agrégation, c'est que lorsqu'Un objet est détruit, l'objet B, il est le stockage sera toujours là. Lors de l'utilisation de la composition, vous avez une relation plus forte, généralement en stockant le membre en valeur:

class A {
    B element;
};

Ici, lorsqu'Un objet est détruit, l'objet B, il contient sera détruite aussi. La façon la plus simple d'y parvenir est par le stockage de la membre de la valeur, mais vous pouvez également utiliser certains pointeur intelligent, ou de supprimer le membre dans le destructeur:

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

class A {
    B * element;

    ~A() {
        delete B;
    }
};

Le point important est que, dans une composition, l'objet conteneur possède le contenu de l'un, tandis que dans l'agrégation, il références il.

Association

Association représente la relation entre les deux classes.Il peut être unidirectionnelle(d'une manière) ou bidirectionnelle(two way)

par exemple:

1. unidirectionnel

Par le client des commandes

1. bidirectionnel

Un est marié à B

B est marié à Une

Agrégation

Agrégation est une forme d'association.Mais avec des caractéristiques spécifiques.L'agrégation est la relation dans un grand "tout" classe contient un ou plusieurs petites "pièces" des classes.À l'inverse, une plus petite "partie" de la classe est une partie de "tout" le plus grand de la classe.

par exemple:

club a des membres

Un club("ensemble") est composé de plusieurs membres du club("parties").Les membres de la vie à l'extérieur du club. Si le club("ensemble") étaient à mourir, les membres("parties") ne serait pas mourir avec elle. Parce que les membres peuvent appartenir à plusieurs clubs("ensemble").

Composition

C'est une forme plus forte de l'agrégation."Ensemble" est responsable pour la création ou la destruction de ses "parties"

Par exemple:

Une école a des départements

Dans ce cas l'école("ensemble") étaient à mourir, département("parties") mourrait avec elle.
Car chaque partie peut appartenir qu'à un seul "ensemble".

Composition (Si vous supprimez "ensemble", “partie” est également supprimé automatiquement de la “Propriété”)

• De créer des objets de votre classe à l'intérieur de la nouvelle classe. Cela s'appelle de la composition, parce que la nouvelle de la classe est composée d'objets de classes existantes.

• Généralement l'utilisation normale des variables membres.

• Pouvez utiliser les valeurs de pointeur si la composition de la classe gère automatiquement l'allocation/désallocation responsable de la création/destruction de sous-classes.

Composition en 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);
}

Sortie

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

Agrégation (Si vous supprimez "ensemble", “Partie” peut exister, “ Pas de Propriété”)

• Une agrégation est un type spécifique de composition où aucun droit de propriété entre l'objet complexe et les sous-objets est implicite. Quand un agrégat est détruit, les sous-objets ne sont pas détruits.

• Généralement utiliser le pointeur de variables/variable de référence qui pointent vers un objet qui vit à l'extérieur de la portée de l'ensemble de la classe

• Pouvez utiliser des valeurs de référence qui pointent vers un objet qui vit à l'extérieur de la portée de l'ensemble de la classe

• Pas responsable de la création et de détruire les sous-classes

Agrégation de Code en 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);
}

Sortie

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

Problème avec ces réponses, c'est qu'ils sont la moitié de l'histoire: ils expliquent que l'agrégation et la composition sont des formes d'association, mais ils ne disent pas si c'est possible pour une association d'être ni de ceux-ci.

Je rassemble basée sur quelques lectures de nombreux postes sur et que certains UML docs qu'il y a 4 principales formes concrètes de l'association de la classe:

1. composition: Un est-composé-de-a, B; B n'existe pas sans Un, comme une chambre dans une maison
2. agrégation: a a-a B; B peut exister sans Un, comme un étudiant en classe
3. la dépendance: Un utilise-un B, aucun cycle de vie dépendance entre A et B, comme un appel de méthode en paramètre, la valeur de retour, ou temporaire créée lors d'un appel de méthode
4. généralisation: Un est-a B

Quand une relation entre deux entités n'est pas un de ces, il peut juste être appelé "une association au sens générique du terme, et décrit d'autres méthodes (remarque, stéréotype, etc).

Ma conjecture est que le "générique de" l'association est destiné à être utilisé principalement dans deux cas:

• lorsque les spécificités de la relation sont toujours en cours d'élaboration; de telles relations dans un diagramme doit être converti dès que possible de ce qu'elle est réellement/sera (l'un des 4 autres).
• quand une relation ne correspond à aucune de ces 4 prédéterminée par UML; le "générique" de l'association vous offre un moyen de représenter une relation qui "n'est pas l'un de l'autre", de sorte que vous n'êtes pas coincé en utilisant une mauvaise relation avec une note de "ce n'est pas réellement l'agrégation, c'est juste qu'UML n'ont pas de n'importe quel autre symbole que nous pourrions utiliser"

J'aimerais illustrer comment les trois termes sont mis en œuvre dans les Rails. ActiveRecord appels de n'importe quel type de relation entre deux modèles une association. On ne pourrait pas trouver très souvent les termes composition et aggregation, lors de la lecture de documents ou d'articles liés à ActiveRecord. Une association est créée par l'ajout de l'association à la classe des macros pour le corps de la classe. Certains de ces macros sont belongs_to, has_one, has_many etc..

Si nous voulons mettre en place un composition ou aggregation, nous avons besoin d'ajouter belongs_to à la propriété modèle (également appelé enfant) et has_one ou has_many pour le propriétaire modèle (également appelée "société mère"). Si nous avons mis en place composition ou aggregation dépend des options que nous passons à la belongs_to appel dans le modèle de l'enfant. Avant de Rails 5, la configuration de belongs_to sans les options créé un aggregation, l'enfant pourrait exister sans un parent. Si nous voulions un composition, nous avons besoin de déclarer explicitement par l'ajout de l'option required: true:

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

Dans les Rails 5 ce qui a changé. Maintenant, la déclaration d'une belongs_to association crée un composition par défaut, l'enfant ne peut exister sans un parent. Ainsi l'exemple ci-dessus peut être réécrite sous la forme:

class Room < ApplicationRecord
  belongs_to :house
end

Si nous voulons permettre à l'enfant de l'objet à exister sans un parent, nous avons besoin de le déclarer explicitement via l'option optional

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

Dans un très simple phrase:

L'agrégation et la Composition sont des sous-ensembles de l'association.

• A utilise B -> c'est une agrégation

• Des besoins B -> est de la composition.

Lire plus ici.