Aggregazione vs composizione

Capisco quale sia la composizione in OOP, ma non sono in grado di avere un'idea chiara di cosa sia Aggregazione. Qualcuno può spiegare?

Regole semplici:

1. A "possiede" B = Composizione: B non ha significato o scopo nel sistema senza A
2. A "usa" B = Aggregazione: B esiste indipendentemente (concettualmente) da A

Esempio 1:

Una società è un'aggregazione di persone. Una società è una composizione di conti. Quando una società cessa di fare affari, i suoi conti cessano di esistere ma i suoi dipendenti continuano a esistere.

Esempio 2: (molto semplificato)

Un editor di testo possiede un buffer (composizione). Un editor di testo utilizza un file (aggregazione). Quando l'Editor di testo viene chiuso, il buffer viene distrutto ma il file stesso non viene distrutto.

Da http://en.wikipedia.org/wiki/Object_composition

L'aggregazione differisce dalla composizione ordinaria in quanto non implica la proprietà. Nella composizione, quando l'oggetto proprietario viene distrutto, lo sono anche gli oggetti contenuti. Nel complesso, questo non è necessariamente vero. Ad esempio, un'università possiede vari dipartimenti (ad es. Chimica) e ogni dipartimento ha un numero di professori. Se l'università chiuderà, i dipartimenti non esisteranno più, ma i professori in quei dipartimenti continueranno ad esistere. Pertanto, un'università può essere vista come una composizione di dipartimenti, mentre i dipartimenti hanno un'aggregazione di professori. Inoltre, un professore potrebbe lavorare in più di un dipartimento, ma un dipartimento non potrebbe far parte di più di un'università.

Quindi - mentre hai una relazione di proprietà con la composizione, l'oggetto posseduto viene distrutto anche quando il proprietario lo è - un'aggregazione (e gli oggetti contenuti) può esistere indipendentemente.

-

Aggiornamento: scuse: questa risposta è troppo semplicistica col senno di poi.

c.batt fornisce una definizione eccellente nella sua risposta: aggregazione vs composizione

Non c'è una sola spiegazione. Autori diversi significano cose diverse per aggregazione. La maggior parte non significa nulla di specifico.

• La composizione è un'associazione

• L'aggregazione è un'associazione

• La composizione è un'associazione forte (se la vita dell'oggetto contenuto dipende totalmente dall'oggetto contenitore, si chiama associazione forte)

• L'aggregazione è un'associazione debole (se la durata dell'oggetto contenuto non dipende dall'oggetto contenitore, si chiama associazione debole)

Esempio:

class Contained {
    public void disp() {
        System.out.println("disp() of Contained A");
    }
}

public class Container {
    private Contained c;

    //Composition
    Container() {
        c = new Contained(); 
    }

    //Association 
    public Contained getC() {
        return c;
    }

    public void setC(Contained c) {
        this.c = c;
    }     

    public static void main(String[] args) {
        Container container = new Container();
        Contained contained = new Contained();
        container.setC(contained);
    } 
}

La composizione (miscela) è un modo per combinare oggetti semplici o tipi di dati in più complessi. Le composizioni sono un componente fondamentale di molte strutture di dati di base

L'aggregazione (raccolta) differisce dalla composizione ordinaria in quanto non implica la proprietà. Nella composizione, quando l'oggetto proprietario viene distrutto, lo sono anche gli oggetti contenuti. Nel complesso, questo non è necessariamente vero

╔═══════════╦═════════════════════════╦═══════════════════════╗
║           ║       Aggregation       ║      Composition      ║
╠═══════════╬═════════════════════════╬═══════════════════════╣
║ Life time ║ Have their own lifetime ║ Owner's life time     ║
║ Relation  ║ Has                     ║ part-of               ║
║ Example   ║ Car has driver          ║ Engine is part of Car ║
╚═══════════╩═════════════════════════╩═══════════════════════╝

Entrambi indicano una relazione tra oggetto e differiscono solo per la loro forza.

Notazioni UML per diversi tipi di dipendenza tra due classi

Composizione : dal momento che Engine è parte di Car, la relazione tra loro è Composizione. Ecco come vengono implementate tra le classi Java.

public class Car {
    //final will make sure engine is initialized
    private final Engine engine;  

    public Car(){
       engine  = new Engine();
    }
}

class Engine {
    private String type;
}

Aggregazione : poiché l'organizzazione ha Persona come dipendente, la relazione tra loro è Aggregazione. Ecco come appaiono in termini di classi Java

public class Organization {
    private List employees;
}


public class Person {
    private String name;   
}

fonte

l'aggregazione è una raccolta semplice, come una borsa di marmi

la composizione implica dipendenze interne / funzionali, come le cerniere su una scatola

passeggeri aggregati di automobili; entrano ed escono senza interrompere la funzionalità dell'auto

le gomme sono componenti; rimuoverne uno e l'auto non funziona più correttamente

[nota: la ruota di scorta è un aggregato!]

Osservo sempre la composizione come "ha bisogno di un", cioè un'auto ha bisogno di un motore e guardo l'aggregazione come "cose ​​legate a uno scopo". Quindi, stando all'analogia con l'auto, la mia aggregazione potrebbe essere quella di rappresentare un viaggio che potrebbe comportare il riunire un'auto e passeggeri. Il viaggio non è proprietario dell'auto o dei passeggeri, sto aggregando i dati relativi a uno scenario specifico. Quando il viaggio è completato, l'auto e i passeggeri proseguono. Quando un'auto è finita, l'auto e il suo motore vengono normalmente distrutti insieme.

Semanticamente, tutti gli insiemi sono costituiti da sottoinsiemi, giusto? Perciò:

• L'aggregazione avviene quando tali sottoinsiemi esistono indipendentemente dall'insieme padre. Come monitor può essere scollegato dal computer per essere collegato a un altro.

• La composizione è quando questi sottoinsiemi dipendono dall'esistenza del set padre. Poiché una foglia fa parte di un albero o il fegato fa parte di un corpo.

Questi concetti parlano concettualmente del tipo di dipendenza tra due oggetti o classi. Direttamente in un programma, in un'aggregazione, quando l'oggetto padre dispone, anche gli oggetti aggregati devono essere eliminati. Nello stesso scenario per una composizione, gli oggetti figlio compositi persistono, quindi l'oggetto padre viene distribuito.

Che ne dici di questo semplice esempio:

Una matrice di oggetti è una composizione. Una matrice di puntatori agli oggetti è un'aggregazione.

Se cancello il primo, il suo contenuto svanisce con esso. Il secondo, d'altra parte, può svanire senza influire sull'esistenza dei suoi membri a meno che non esista un metodo specifico che elimini ciascun oggetto quando il suo puntatore viene eliminato.