Differenza di implementazione tra aggregazione e composizione in Java

Sono consapevole delle differenze concettuali tra Aggregazione e Composizione. Qualcuno può dirmi la differenza di implementazione in Java tra di loro con esempi?

Composizione

final class Car {

  private final Engine engine;

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

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

Aggregazione

final class Car {

  private Engine engine;

  void setEngine(Engine engine) {
    this.engine = engine;
  }

  void move() {
    if (engine != null)
      engine.work();
  }
}

In caso di composizione, il Motore è completamente incapsulato dall'Auto. Non c'è modo per il mondo esterno di ottenere un riferimento al motore. Il motore vive e muore con l'auto. Con l'aggregazione, l'Auto svolge le sue funzioni anche attraverso un Motore, ma il Motore non è sempre una parte interna dell'Auto. I motori possono essere scambiati o addirittura completamente rimossi. Non solo, ma il mondo esterno può ancora avere un riferimento al Motore e armeggiare con esso indipendentemente dal fatto che sia nell'Auto.

Vorrei usare un bell'esempio di UML.

Prendi un'università che abbia da 1 a 20 dipartimenti diversi e ogni dipartimento ha da 1 a 5 professori. Esiste un collegamento di composizione tra un'università e i suoi dipartimenti. Esiste un legame di aggregazione tra un dipartimento e i suoi professori.

La composizione è solo una FORTE aggregazione, se l'università viene distrutta, anche i dipartimenti dovrebbero essere distrutti. Ma non dovremmo uccidere i professori anche se i loro rispettivi dipartimenti scompaiono.

In Java:

public class University {

     private List<Department> departments;

     public void destroy(){
         //it's composition, when I destroy a university I also destroy the departments. they cant live outside my university instance
         if(departments!=null)
             for(Department d : departments) d.destroy();
         departments.clean();
         departments = null;
     }
}

public class Department {

     private List<Professor> professors;
     private University university;

     Department(University univ){
         this.university = univ;
         //check here univ not null throw whatever depending on your needs
     }

     public void destroy(){
         //It's aggregation here, we just tell the professor they are fired but they can still keep living
         for(Professor p:professors)
             p.fire(this);
         professors.clean();
         professors = null;
     }
}

public class Professor {

     private String name;
     private List<Department> attachedDepartments;

     public void destroy(){

     }

     public void fire(Department d){
         attachedDepartments.remove(d);
     }
}

Qualcosa intorno a questo.

C'è un'ottima spiegazione nell'URL fornito di seguito.

http://www.codeproject.com/Articles/330447/Understanding-Association-Aggregation-and-Composit

Si prega di controllare!!!

La differenza è che qualsiasi composizione è un'aggregazione e non viceversa.

Definiamo i termini. L'aggregazione è un metaterm nello standard UML e significa SIA composizione e aggregazione condivisa, semplicemente denominata condivisa . Troppo spesso viene chiamato in modo errato "aggregazione". È MALE, perché anche la composizione è un'aggregazione. A quanto ho capito, intendi "condiviso".

Più lontano dallo standard UML:

composito - Indica che la proprietà è aggregata in modo composito, ovvero l'oggetto composto è responsabile dell'esistenza e della memorizzazione degli oggetti composti (parti).

Quindi, l'associazione University to cathedras è una composizione, perché la cathedra non esiste fuori dall'università (IMHO)

La semantica precisa dell'aggregazione condivisa varia in base all'area di applicazione e al modellatore.

Cioè, tutte le altre associazioni possono essere disegnate come aggregazioni condivise, se segui solo alcuni principi tuoi o di qualcun altro. Guarda anche qui .

In parole povere :

Sia la composizione che l'aggregazione sono associazioni. Composizione -> Relazione Has-A forte Aggregazione -> Relazione Has-A debole.

Un semplice programma di composizione

public class Person {
    private double salary;
    private String name;
    private Birthday bday;

    public Person(int y,int m,int d,String name){
        bday=new Birthday(y, m, d);
        this.name=name;
    }


    public double getSalary() {
        return salary;
    }

    public String getName() {
        return name;
    }

    public Birthday getBday() {
        return bday;
    }

    ///////////////////////////////inner class///////////////////////
    private class Birthday{
        int year,month,day;

        public Birthday(int y,int m,int d){
            year=y;
            month=m;
            day=d;
        }

        public String toString(){
           return String.format("%s-%s-%s", year,month,day);

        }
    }

    //////////////////////////////////////////////////////////////////

}
public class CompositionTst {

    public static void main(String[] args) {
        // TODO code application logic here
        Person person=new Person(2001, 11, 29, "Thilina");
        System.out.println("Name : "+person.getName());
        System.out.println("Birthday : "+person.getBday());

        //The below object cannot be created. A bithday cannot exixts without a Person 
        //Birthday bday=new Birthday(1988,11,10);

    }
}

Per prima cosa dobbiamo parlare di quale sia effettivamente la differenza tra Aggregatione Compositionessere sulla stessa pagina.

L'aggregazione è un'associazione in cui l'entità associata può esistere indipendentemente dall'associazione. Ad esempio, una persona può essere associata a un'organizzazione ma può avere un'esistenza indipendente nel sistema.

mentre

La composizione si riferisce a una situazione in cui una delle entità associate è fortemente correlata all'altra e non può esistere senza l'esistenza dell'altra. Infatti l'identità di quell'entità è sempre associata all'identità dell'altro oggetto. Ad esempio, le ruote di un'auto.

Ora, l'aggregazione può essere ottenuta semplicemente mantenendo una proprietà di un'entità in un'altra come di seguito:

class Person {
    Organisation worksFor;
}

class Organisation {
    String name;
}

class Main {
    public static void main(String args[]) {

        //Create Person object independently
        Person p = new Person();

        //Create the Organisation independently
        Organisation o = new Organisation();
        o.name = "XYZ Corporation";

        /*
          At this point both person and organisation 
          exist without any association  
        */
        p.worksFor = o;

    }
}

Per la composizione è necessario che l'oggetto dipendente sia sempre creato con l'identità dell'oggetto associato. Puoi usare una classe interna per lo stesso.

class Car {
    class Wheel {
        Car associatedWith;
    }
}

class Main {
    public static void main() {
        //Create Car object independently
        Car car = new Car();

        //Cannot create Wheel instance independently
        //need a reference of a Car for the same.
        Car.Wheel wheel = car.new Wheel();
    }
}

Si noti che lo stesso caso d'uso può rientrare nell'aggregazione / composizione a seconda dello scenario dell'applicazione. Ad esempio, il caso Persona-Organizzazione può diventare composizione se stai sviluppando un'applicazione per persone che lavorano in un'organizzazione e il riferimento all'organizzazione è obbligatorio per l'iscrizione. Allo stesso modo, se gestisci l'inventario per parti di un'auto, la relazione Auto-Ruota può essere aggregata.

Aggregazione vs Composizione

L'aggregazione implica una relazione in cui il bambino può esistere indipendentemente dal genitore. Ad esempio, Banca e dipendente, elimina la banca e il dipendente esiste ancora.

mentre la composizione implica una relazione in cui il bambino non può esistere indipendentemente dal genitore. Esempio: Umano e cuore, il cuore non esistono separati da un Umano.

La relazione di aggregazione è "ha-a" e la composizione è "parte di" relazione.

La composizione è un'associazione forte mentre l'aggregazione è un'associazione debole.

Entrambi i tipi sono ovviamente associazioni e non sono realmente mappati strettamente a elementi del linguaggio come quello. La differenza sta nello scopo, nel contesto e nel modo in cui il sistema è modellato.

Come esempio pratico, confronta due diversi tipi di sistemi con entità simili:

• Un sistema di registrazione delle auto che tiene principalmente traccia delle auto, dei loro proprietari, ecc. Qui non siamo interessati al motore come entità separata, ma potremmo ancora avere attributi relativi al motore, come potenza e tipo di carburante. Qui il motore può essere una parte composita dell'entità auto.

• Un sistema di gestione del negozio di servizi per auto che gestisce parti di automobili, manutenzione di automobili e sostituzione di parti, magari motori completi. Qui potremmo anche avere motori riforniti e dover tenere traccia di loro e di altre parti separatamente e indipendentemente dalle auto. Qui il motore può essere una parte aggregata dell'entità auto.

Il modo in cui lo implementate nella vostra lingua è di minore importanza poiché a quel livello cose come la leggibilità sono molto più importanti.