Différence d'implémentation entre agrégation et Composition en Java

j'utiliserais un bel exemple UML.

pris une université a 1 à 20 département différents et chaque département a 1 à 5 professeurs. Il existe un lien de composition entre une université et ses départements. Il existe un lien d'agrégation entre un département et ses professeurs.

la Composition n'est qu'une agrégation forte, si l'université est détruite alors les départements devraient aussi être détruits. Mais on ne devrait même pas tuer les professeurs. si leurs départements respectifs disparaissent.

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

quelque chose autour de ça.

un programme de Composition simple

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

    }
}

la différence est que toute composition est une agrégation et non l'inverse.

fixons les conditions. L'agrégation est un métaterme dans la norme UML, et signifie à la fois la composition et l'agrégation partagée, simplement appelé partagé . Trop souvent, il est nommé incorrectement "agrégation". C'est mauvais, car la composition est aussi une agrégation. Si je comprends bien, vous voulez dire "partagé".

plus loin de la norme UML:

composite-indique que la propriété est agrégée de façon composite, c'est-à-dire que l'objet composite est responsable de l'existence et stockage des objets composés (pièces).

ainsi, L'association Université-cathedras est une composition, parce que la cathedra n'existe pas hors de L'Université (IMHO)

la sémantique précise de l'agrégation partagée varie selon le domaine d'application et le type d'agrégation. modeleur.

c'est-à-dire, toutes les autres associations peuvent être dessinées comme des agrégations partagées, si vous suivez seulement certains de vos principes ou de quelqu'un d'autre. Regardez aussi ici .

en termes simples:

la Composition et L'agrégation sont toutes deux des Associations. Composition - > forte a-une relation Agrégation - > faible a-une relation.

il y a une grande explication dans l'url donnée ci-dessous.

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

s'il vous Plaît vérifier!!!

nous devons D'abord parler de ce que la différence entre Aggregation et Composition doit être sur la même page.

L'agrégation

est une association dans laquelle l'entité associée peut exister indépendamment de l'association. Par exemple, une personne peut être associée à une Organisation, mais elle peut avoir une existence indépendante dans le système.

attendu que

Composition se réfère à une situation où l'une des entités est fortement liée à l'autre et ne peuvent exister l'une sans l'autre. En fait, l'identité de cette entité est toujours associée à l'identité de l'autre objet. Par exemple, des roues dans une voiture.

maintenant, l'agrégation peut simplement être réalisée en maintenant une propriété d'une entité dans une autre comme ci-dessous:

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;

    }
}

pour la Composition il est nécessaire que le dépendant l'objet est toujours créé avec l'identité de son objet associé. Vous pouvez utiliser une classe intérieure pour la même chose.

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

veuillez noter que le même cas d'utilisation peut faire l'objet d'une agrégation/composition selon le scénario d'application. Par exemple, le cas personne-Organisation peut devenir composition si vous développez une demande pour les personnes travaillant dans une organisation et la référence à l'organisation est nécessaire pour s'inscrire. De même, si vous sont la tenue de l'inventaire pour les pièces d'un wagon, la relation Wagon-roue peut être agrégation.

ces deux types sont bien sûr des associations, et ne sont pas vraiment associés strictement à des éléments linguistiques comme celui-ci. La différence réside dans le but, le contexte et la façon dont le système est modélisé.

comme exemple pratique, comparez deux types différents de systèmes avec des entités similaires:

• un système d'immatriculation de voitures qui principalement garder la trace des voitures, et leurs propriétaires, etc. Ici nous ne sommes pas intéressés à le moteur en tant qu'entité séparée, mais nous pouvons toujours avoir des attributs liés au moteur, comme la puissance, et le type de carburant. Ici, le moteur peut être une composite partie de l'entité de la voiture.

• Une voiture de service de la boutique de gestion du système qui permet de gérer les pièces de voiture, l'entretien des voitures, et de remplacer les pièces, peut-être les moteurs complets. Ici, nous pouvons même avoir des moteurs en stock et besoin de garder une trace d'eux et d'autres parties séparément et indépendant des voitures. Ici, le moteur peut être une agrégé partie de l'entité de la voiture.

la façon dont vous mettez en œuvre ce principe dans votre langue est une préoccupation mineure, car à ce niveau, les choses comme la lisibilité sont beaucoup plus importantes.