Implementation difference between Aggregation and Composition in Java

Question

I m aware of the conceptual differences between Aggregation and Composition  Can someone tell me the implementation difference in Java between them with examples

User · Answer

First we must talk about what actually the difference between Aggregation and Composition is to be on the same page.

Aggregation is an association where the associated entity may exist independent of the association. For example, a Person may be associated to an Organisation but he/she may have independent existence in the system.

whereas

Composition refers to a situation when one of the associated entities is strongly related to the other and cannot exist without the other's existence. In fact the identity of that entity is always associated with the identity of the other object. For example, wheels in a car.

Now, aggregation can simply be achieved by holding a property of one entity in another as below:

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;

    }
}

For Composition it is necessary that the dependent object is always created with the identity of its associated object. You can use an inner class for the same.

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

Please note that the same use case may fall under aggregation/composition depending on the application scenario. For example, the Person-Organisation case may become composition if you are developing an application for people working in some organisation and the reference to organisation is must for sign up. Similarly, if you are maintaining inventory for parts of a Car, Car-Wheel relationship can be aggregation.

User · Answer

I would use a nice UML example  Take a university that has 1 to 20 different departments and each department has 1 to 5 professors  There is a composition link between a University and its  departments  There is an aggregation link between a department and its  professors  Composition is just a STRONG aggregation  if the university is destroyed then the departments should also be destroyed  But we shouldn t kill the professors even if their respective departments disappear  In java   public class University         private List lt Department gt  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 lt Professor gt  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 lt Department gt  attachedDepartments        public void destroy                  public void fire Department d            attachedDepartments remove d             Something around this  EDIT  an example as requested public class Test       public static void main String   args                University university   new University              the department only exists in the university         Department dep   university createDepartment               the professor exists outside the university         Professor prof   new Professor  quot Raoul quot            System out println university toString             System out println prof toString              dep assign prof           System out println university toString             System out println prof toString             dep destroy             System out println university toString             System out println prof toString                 University class import java util ArrayList  import java util List  import java util stream Collectors   public class University        private List lt Department gt  departments   new ArrayList lt  gt          public Department createDepartment             final Department dep   new Department this   quot Math quot            departments add dep           return dep             public void destroy             System out println  quot Destroying university quot              it s composition  when I destroy a university I also destroy the departments  they cant live outside my university instance         if  departments    null              departments forEach Department  destroy           departments   null              Override     public String toString             return  quot University  n quot                     quot departments  n quot    departments stream   map Department  toString  collect Collectors joining  quot  n quot                       quot  n  quot            Department class import java util ArrayList  import java util List  import java util stream Collectors   public class Department        private final String name      private List lt Professor gt  professors   new ArrayList lt  gt         private final University university       public Department University univ  String name            this university   univ          this name   name            check here univ not null throw whatever depending on your needs            public void assign Professor p              maybe use a Set here         System out println  quot Department hiring  quot    p getName             professors add p           p join this              public void fire Professor p              maybe use a Set here         System out println  quot Department firing  quot    p getName             professors remove p           p quit this              public void destroy               It s aggregation here  we just tell the professor they are fired but they can still keep living         System out println  quot Destroying department quot            professors forEach professor - gt  professor quit this            professors   null              Override     public String toString             return professors    null                    quot Department  quot    name    quot  doesn t exists anymore quot                     quot Department  quot    name    quot   n quot                     quot professors  quot    professors stream   map Professor  toString  collect Collectors joining  quot  n quot                       quot  n  quot            Professor class import java util ArrayList  import java util List   public class Professor        private final String name      private final List lt Department gt  attachedDepartments   new ArrayList lt  gt          public Professor String name            this name   name             public void destroy                 public void join Department d            attachedDepartments add d              public void quit Department d            attachedDepartments remove d              public String getName             return name              Override     public String toString             return  quot Professor  quot    name    quot  working for  quot    attachedDepartments size      quot  department s  n quot            The implementation is debatable as it depends on how you need to handle creation  hiring deletion etc  Unrelevant for the OP

User · Answer

In simple terms     Both Composition and Aggregation are Associations   Composition -  Strong Has-A relationship  Aggregation -  Weak Has-A relationship

User · Answer

A simple Composition program   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

User · Answer

The difference is that any composition is an aggregation and not vice versa   Let s set the terms  The Aggregation is a metaterm in the UML standard  and means BOTH composition and shared aggregation  simply named shared  Too often it is named incorrectly  aggregation   It is BAD  for composition is an aggregation  too  As I understand  you mean  shared    Further from UML standard      composite - Indicates that the property is aggregated compositely    i e   the composite object has responsibility for the existence and   storage of the composed objects  parts     So  University to cathedras association is a composition  because cathedra doesn t exist out of University  IMHO      Precise semantics of shared aggregation varies by application area and   modeler    I e   all other associations can be drawn as shared aggregations  if you are only following to some principles of yours or of somebody else  Also look here

User · Answer

Both types are of course associations  and not really mapped strictly to language elements like that  The difference is in the purpose  context  and how the system is modeled   As a practical example  compare two different types of systems with similar entities    A car registration system that primarily keep track of cars  and their owners  etc  Here we are not interested in the engine as a separate entity  but we may still have engine related attributes  like power  and type of fuel  Here the Engine may be a composite part of the car entity  A car service shop management system that manages car parts  servicing cars  and replace parts  maybe complete engines  Here we may even have engines stocked and need to keep track of them and other parts separately and independent of the cars  Here the Engine may be an aggregated part of the car entity    How you implement this in your language is of minor concern since at that level things like readability is much more important

User · Answer

Composition  final class Car      private final Engine engine     Car EngineSpecs specs        engine   new Engine specs          void move         engine work            Aggregation  final class Car      private Engine engine     void setEngine Engine engine        this engine   engine         void move         if  engine    null        engine work            In the case of composition  the Engine is completely encapsulated by the Car  There is no way for the outside world to get a reference to the Engine  The Engine lives and dies with the car  With aggregation  the Car also performs its functions through an Engine  but the Engine is not always an internal part of the Car  Engines may be swapped  or even completely removed  Not only that  but the outside world can still have a reference to the Engine  and tinker with it regardless of whether it s in the Car

User · Answer

There is a great explanation in the given url below     http   www codeproject com Articles 330447 Understanding-Association-Aggregation-and-Composit  Please check

User · Answer

Aggregation vs Composition  Aggregation implies a relationship where the child can exist independently of the parent  For example  Bank and Employee  delete the Bank and the Employee still exist   whereas Composition implies a relationship where the child cannot exist independent of the parent  Example  Human and heart  heart don   t exist separate to a Human   Aggregation relation is    has-a    and composition is    part-of    relation   Composition is a strong Association whereas Aggregation is a weak Association

[java] Implementation difference between Aggregation and Composition in Java

Examples related to java

Examples related to relationship

Examples related to aggregation

Examples related to composition