Qual è la differenza tra relazione di composizione e associazione?

In OOP, qual è la differenza tra la composizione (denotata dal diamante riempito in UML) e l’associazione (denotata dal diamante vuoto in UML) tra le classi. Sono un po ‘confuso. Cos’è l’aggregazione? Posso avere un esempio convincente del mondo reale?

COMPOSIZIONE

Immagina una società di software composta da diverse Business Unit (o dipartimenti) come BU Magazzino, BU Rete. BU Automobile. La durata di vita di queste Business Unit è regolata dalla durata dell’organizzazione. In altre parole, queste Business Unit non possono esistere indipendentemente senza l’impresa. Questa è COMPOSIZIONE. (ovvero l’azienda è COMPOSTA di unità aziendali)

ASSOCIAZIONE

L’azienda produttrice di software può avere catering esterni che servono cibo ai dipendenti. Questi ristoratori NON fanno parte dell’azienda. Tuttavia, sono associati con l’azienda. I ristoratori possono esistere anche se la nostra azienda di software è chiusa. Possono servire un’altra impresa! Quindi la vita dei ristoratori non dipende dalla durata della ditta di software. Questa è l’ASSOCIAZIONE tipica

AGGREGAZIONE

Si consideri un’unità di produzione di automobili. Possiamo pensare a Car come a un’ quadro intera e Car Wheel come parte della macchina. (a questo punto, può sembrare una composizione … continua su) La ruota può essere creata settimane prima del tempo e può essere posizionata in un magazzino prima di essere posizionata su una macchina durante il assembly. In questo esempio, l’istanza della class Wheel vive chiaramente indipendentemente dall’istanza della class Car. Pertanto, a differenza della composizione, in aggregazione, i cicli di vita degli oggetti coinvolti non sono strettamente accoppiati.

Ecco alcuni esempi:

  • Sono un dipendente di un’azienda, quindi sono associato a tale società. Io non ne faccio parte, né lo compongo, ma sono collegato ad esso, comunque.

  • Sono composto da organi che, a meno che non vengano trapiantati, moriranno con me. Questa è composizione, che è un legame molto forte tra gli oggetti. Fondamentalmente gli oggetti sono composti da altri oggetti. Il verbo dice tutto.

  • C’è anche un altro tipo di composizione meno legata, chiamata aggregazione. Un’aggregazione è quando gli oggetti sono composti da altri oggetti, ma i loro cicli di vita non sono necessariamente legati. Usando un esempio estremo, un giocattolo Lego è un’aggregazione di parti. Anche se il giocattolo può essere smontato, le sue parti possono essere ricomposte per creare un giocattolo diverso.

Possedere e usare.

Composizione: l’object con il riferimento possiede l’object a cui si riferisce ed è responsabile della sua “vita”, della sua distruzione (e spesso della sua creazione, sebbene possa essere trasmessa). Conosciuto anche come relazione has-a .

Associazione: l’object con il riferimento utilizza l’object a cui si fa riferimento, potrebbe non essere un utente esclusivo e non è responsabile per la durata dell’object di cui fa riferimento. Conosciuto anche come una relazione usa-una .

I commenti OP:

Puoi fornire un esempio del mondo reale. Inoltre, cos’è l’aggregazione? – Marc

Aggregazione: un’associazione che va da tutto a parte e che non può essere ciclica.

Esempi:

Composizione: un’auto ha un motore, una persona ha un indirizzo. Fondamentalmente, deve avere, controlla la durata.

Associazione: un’Auto ha un Driver, qualche istanza di class ha-un ErrorLogger. La durata non controllata, può essere condivisa.

Aggregazione: un DOM (modello object documento, ovvero gli oggetti che compongono un albero di elementi HTML) Il nodo ha-a (una matrice di) nodes figli. Il nodo è il livello superiore (bene, più alto); esso “contiene” i suoi figli, non lo contengono.

Credo che un esempio basato su codice possa aiutare a illustrare i concetti dati dalle risposte di cui sopra.

import java.util.ArrayList; public final class AssoCia { public static void main( String args[] ) { B b = new B(); ArrayList cs = new ArrayList(); A a = new A( b, cs ); a.addC( new C() ); a.addC( new C() ); a.addC( new C() ); a.listC(); } } class A { // Association - // this instance has a object of other class // as a member of the class. private B b; // Association/Aggregation - // this instance has a collection of objects // of other class and this collection is a // member of this class private ArrayList cs; private D d; public A(B b, ArrayList cs) { // Association this.b = b; // Association/Aggregation this.cs = cs; // Association/Composition - // this instance is responsible for creating // the instance of the object of the // other class. Therefore, when this instance // is liberated from the memory, the object of // the other class is liberated, too. this.d = new D(); } // Dependency - // only this method needs the object // of the other class. public void addC( C c ) { cs.add( c ); } public void listC() { for ( C c : cs ) { System.out.println( c ); } } } class B {} class C {} class D {} 

Di solito, composizione significa che la durata dell’object contenuto è limitata da quella del contenitore, mentre l’associazione è un riferimento a un object che può esistere indipendentemente.

Tuttavia, questa è solo la pratica che ho osservato. Odio ammetterlo, ma scavare attraverso le specifiche UML2 non è in cima alla mia lista di cose divertenti da fare!

Esistenza indipendente

Una fattura è composta da elementi pubblicitari.

Che cos’è un elemento pubblicitario non presente in una fattura? È – beh – non è niente. Non può esistere indipendentemente.

D’altra parte, una fattura è associata a un cliente.

Il cliente ha un’esistenza indipendente, con o senza fattura.

Se le due cose hanno un’esistenza indipendente, possono essere associate.

Se una cosa non può esistere indipendentemente, allora fa parte di una composizione.

La composizione è una relazione più stretta dell’aggregazione. La composizione significa che qualcosa è così fortemente correlato a qualcos’altro che non possono sostanzialmente esistere indipendentemente, o se possono, vivono in contesti diversi.

Esempio di mondo reale: si definisce una finestra della GUI e quindi un campo di testo in cui scrivere qualcosa. Tra la class che definisce la GUI e la class che definisce il campo di testo c’è la composizione. Insieme, compongono un widget che può essere visto come un’entity framework a sé stante. Supponiamo di cancellare la finestra e di eliminare anche il campo di testo.

L’aggregazione è diversa, nel senso che il collegamento tra le due quadro è temporaneo, instabile e occasionale. Un esempio reale. Supponiamo di avere un database di oggetti contenenti più istanze di dati. Ora si esegue un filtro per raccogliere le istanze di dati che obbediscono a un determinato criterio e le istanze risultanti vengono inserite in un elenco grafico in modo che l’utente possa vederle. Quando il widget grafico riceve gli oggetti, può formare un’aggregazione di queste quadro e presentarle. Se l’utente chiude la finestra con l’elenco grafico e quest’ultimo viene eliminato, gli oggetti dati non devono essere cancellati. Forse vengono visualizzati da qualche altra parte, o ne hai ancora bisogno.

Inoltre, in generale, la composizione è definita al momento della creazione. L’aggregazione viene invece definita successivamente nella durata dell’object.

Composizione significa che una parte dello stato dell’ quadro è incapsulata da un altro tipo ma è parte concettualmente dello stato dell’ quadro. Ad esempio, potresti avere un tipo di indirizzo e un tipo di quadro dipendente che include un indirizzo.

Associazione indica che un tipo di entity framework è associato a un altro tipo di quadro ma l’ quadro associata non è concettualmente parte dello stato dell’ quadro. Ad esempio, un dipendente può essere associato a un’azienda.