Implementierungsunterschied zwischen Aggregation und Komposition in Java

Ich bin mir der konzeptionellen Unterschiede zwischen Aggregation und Komposition bewusst. Kann mir jemand anhand von Beispielen den Implementierungsunterschied in Java erklären?

Komposition

final class Car {

  private final Engine engine;

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

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

Anhäufung

final class Car {

  private Engine engine;

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

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

Bei der Zusammensetzung ist der Motor vollständig vom Auto eingekapselt. Es gibt keine Möglichkeit für die Außenwelt, einen Verweis auf den Motor zu erhalten. Der Motor lebt und stirbt mit dem Auto. Bei der Aggregation führt das Auto seine Funktionen auch über einen Motor aus, aber der Motor ist nicht immer ein interner Teil des Autos. Motoren können ausgetauscht oder sogar vollständig entfernt werden. Nicht nur das, auch die Außenwelt kann immer noch einen Bezug zum Motor haben und daran basteln, unabhängig davon, ob er sich im Auto befindet.

Ich würde ein schönes UML-Beispiel verwenden.

Nehmen Sie eine Universität mit 1 bis 20 verschiedenen Abteilungen und jeder Abteilung hat 1 bis 5 Professoren. Zwischen einer Universität und ihren Abteilungen besteht eine kompositorische Verbindung. Zwischen einer Abteilung und ihren Professoren besteht eine Aggregationsverbindung.

Die Zusammensetzung ist nur eine STARKE Aggregation. Wenn die Universität zerstört wird, sollten auch die Abteilungen zerstört werden. Aber wir sollten die Professoren nicht töten, selbst wenn ihre jeweiligen Abteilungen verschwinden.

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

Etwas um das herum.

Die unten angegebene URL enthält eine gute Erklärung.

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

Bitte prüfen!!!

Der Unterschied besteht darin, dass jede Komposition eine Aggregation ist und nicht umgekehrt.

Lassen Sie uns die Bedingungen festlegen. Die Aggregation ist ein Metaterm im UML-Standard und bedeutet BEIDE Zusammensetzung und gemeinsame Aggregation, einfach als gemeinsam bezeichnet . Zu oft wird es fälschlicherweise als "Aggregation" bezeichnet. Es ist SCHLECHT, denn Komposition ist auch eine Aggregation. Soweit ich weiß, meinst du "geteilt".

Weiter vom UML-Standard:

zusammengesetzt - Gibt an, dass die Eigenschaft zusammengesetzt aggregiert wird, dh das zusammengesetzte Objekt ist für die Existenz und Speicherung der zusammengesetzten Objekte (Teile) verantwortlich.

Die Assoziation von Universität zu Kathedrale ist also eine Komposition, da Kathedra nicht außerhalb der Universität existiert (IMHO).

Die genaue Semantik der gemeinsamen Aggregation variiert je nach Anwendungsbereich und Modellierer.

Das heißt, alle anderen Assoziationen können als gemeinsame Aggregationen gezeichnet werden, wenn Sie nur einigen Prinzipien von Ihnen oder von jemand anderem folgen. Schauen Sie auch hier .

In einfachen Worten :

Sowohl Zusammensetzung als auch Aggregation sind Assoziationen. Zusammensetzung -> Starke Has-A-Beziehung Aggregation -> Schwache Has-A-Beziehung.

Ein einfaches Kompositionsprogramm

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

    }
}

Zuerst müssen wir darüber sprechen, was eigentlich der Unterschied zwischen Aggregationund Compositionauf derselben Seite sein soll.

Aggregation ist eine Zuordnung, bei der die zugeordnete Entität unabhängig von der Zuordnung existieren kann. Beispielsweise kann eine Person einer Organisation zugeordnet sein, sie kann jedoch eine unabhängige Existenz im System haben.

wohingegen

Zusammensetzung bezieht sich auf eine Situation, in der eine der assoziierten Einheiten stark mit der anderen verwandt ist und ohne die Existenz der anderen nicht existieren kann. Tatsächlich ist die Identität dieser Entität immer mit der Identität des anderen Objekts verbunden. Zum Beispiel Räder in einem Auto.

Jetzt kann die Aggregation einfach erreicht werden, indem eine Eigenschaft einer Entität in einer anderen wie folgt gehalten wird:

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;

    }
}

Für die Komposition ist es erforderlich, dass das abhängige Objekt immer mit der Identität des zugehörigen Objekts erstellt wird. Sie können eine innere Klasse für dieselbe verwenden.

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();
    }
}

Bitte beachten Sie, dass derselbe Anwendungsfall je nach Anwendungsszenario unter Aggregation / Zusammensetzung fallen kann. Beispielsweise kann der Fall "Person-Organisation" zu einer Zusammensetzung werden, wenn Sie eine Anwendung für Personen entwickeln, die in einer Organisation arbeiten, und der Verweis auf die Organisation für die Anmeldung erforderlich ist. Wenn Sie Inventar für Teile eines Autos führen, kann die Auto-Rad-Beziehung ebenfalls eine Aggregation sein.

Aggregation gegen Zusammensetzung

Aggregation impliziert eine Beziehung, in der das Kind unabhängig vom Elternteil existieren kann . Beispiel: Bank und Mitarbeiter, löschen Sie die Bank und der Mitarbeiter ist noch vorhanden.

Während Komposition eine Beziehung impliziert, in der das Kind nicht unabhängig vom Elternteil existieren kann. Beispiel: Mensch und Herz, Herz existiert nicht getrennt von einem Menschen.

Die Aggregationsbeziehung ist "hat-ein" und die Zusammensetzung ist "Teil der" Beziehung.

Die Zusammensetzung ist eine starke Assoziation, während die Aggregation eine schwache Assoziation ist.

Beide Typen sind natürlich Assoziationen und nicht wirklich streng auf solche Sprachelemente abgebildet. Der Unterschied liegt im Zweck, im Kontext und in der Art und Weise, wie das System modelliert wird.

Vergleichen Sie als praktisches Beispiel zwei verschiedene Systemtypen mit ähnlichen Entitäten:

• Ein Autokennzeichensystem, das in erster Linie die Autos und ihre Besitzer usw. im Auge behält. Hier interessiert uns der Motor nicht als separate Einheit, aber wir haben möglicherweise immer noch motorbezogene Eigenschaften wie Leistung und Kraftstoffart. Hier kann der Motor ein zusammengesetzter Teil der Fahrzeugeinheit sein.

• Ein Managementsystem für Autowerkstätten, das Autoteile verwaltet, Autos wartet und Teile ersetzt, möglicherweise komplette Motoren. Hier haben wir möglicherweise sogar Motoren auf Lager und müssen diese und andere Teile getrennt und unabhängig von den Autos nachverfolgen. Hier kann der Motor ein aggregierter Teil der Fahrzeugeinheit sein.

Wie Sie dies in Ihrer Sprache implementieren, ist von untergeordneter Bedeutung, da auf dieser Ebene Dinge wie Lesbarkeit viel wichtiger sind.