Diferencia de implementación entre agregación y composición en Java

Soy consciente de las diferencias conceptuales entre agregación y composición. ¿Alguien puede decirme la diferencia de implementación en Java entre ellos con ejemplos?

Composición

final class Car {

  private final Engine engine;

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

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

Agregación

final class Car {

  private Engine engine;

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

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

En el caso de la composición, el Motor está completamente encapsulado por el Coche. No hay forma de que el mundo exterior obtenga una referencia al motor. El motor vive y muere con el coche. Con la agregación, el automóvil también realiza sus funciones a través de un motor, pero el motor no siempre es una parte interna del automóvil. Los motores se pueden cambiar o incluso quitar por completo. No solo eso, sino que el mundo exterior aún puede tener una referencia al motor y jugar con él independientemente de si está en el automóvil.

Usaría un buen ejemplo de UML.

Tome una universidad que tenga de 1 a 20 departamentos diferentes y cada departamento tenga de 1 a 5 profesores. Existe un vínculo de composición entre una Universidad y sus departamentos. Existe un vínculo de agregación entre un departamento y sus profesores.

La composición es solo una agregación FUERTE, si se destruye la universidad, los departamentos también deberían destruirse. Pero no deberíamos matar a los profesores incluso si sus respectivos departamentos desaparecen.

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

Algo alrededor de esto.

Hay una gran explicación en la URL dada a continuación.

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

¡¡¡Por favor, compruebe!!!

La diferencia es que cualquier composición es una agregación y no al revés.

Establezcamos los términos. La agregación es un metatérmino en el estándar UML y significa AMBAS composición y agregación compartida, simplemente denominada compartida . Con demasiada frecuencia se denomina incorrectamente "agregación". Es MALO, porque la composición también es una agregación. Según tengo entendido, te refieres a "compartido".

Más allá del estándar UML:

compuesto: indica que la propiedad se agrega de forma compuesta, es decir, el objeto compuesto tiene la responsabilidad de la existencia y el almacenamiento de los objetos compuestos (partes).

Entonces, la asociación de la Universidad a las cátedras es una composición, porque la cátedra no existe fuera de la Universidad (en mi humilde opinión)

La semántica precisa de la agregación compartida varía según el área de aplicación y el modelador.

Es decir, todas las demás asociaciones se pueden dibujar como agregaciones compartidas, si solo está siguiendo algunos principios suyos o de alguien más. También mira aquí .

En lenguaje sencillo :

Tanto la composición como la agregación son asociaciones. Composición -> Fuerte relación Has-A Agregación -> Relación débil Has-A.

Un programa de composición 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);

    }
}

Primero debemos hablar sobre cuál es realmente la diferencia entre Aggregationy Compositiones estar en la misma página.

La agregación es una asociación donde la entidad asociada puede existir independientemente de la asociación. Por ejemplo, una Persona puede estar asociada a una Organización pero puede tener existencia independiente en el sistema.

mientras

La composición se refiere a una situación en la que una de las entidades asociadas está fuertemente relacionada con la otra y no puede existir sin la existencia de la otra. De hecho, la identidad de esa entidad siempre está asociada con la identidad del otro objeto. Por ejemplo, ruedas en un automóvil.

Ahora, la agregación se puede lograr simplemente manteniendo una propiedad de una entidad en otra como se muestra a continuación:

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;

    }
}

Para Composición es necesario que el objeto dependiente siempre se cree con la identidad de su objeto asociado. Puede usar una clase interna para lo mismo.

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

Tenga en cuenta que el mismo caso de uso puede incluirse en la agregación / composición según el escenario de la aplicación. Por ejemplo, el caso Persona-Organización puede convertirse en composición si está desarrollando una aplicación para personas que trabajan en alguna organización y la referencia a la organización es obligatoria para registrarse. De manera similar, si mantiene el inventario de las partes de un automóvil, la relación entre el automóvil y la rueda puede ser agregación.

Agregación vs Composición

La agregación implica una relación en la que el niño puede existir independientemente del padre. Por ejemplo, Banco y Empleado, elimine el Banco y el Empleado todavía existe.

mientras que Composición implica una relación en la que el niño no puede existir independientemente del padre. Ejemplo: Humano y corazón, el corazón no existe separado de un Humano.

La relación de agregación es "tiene-a" y la composición es la relación "parte de".

La composición es una asociación fuerte, mientras que la agregación es una asociación débil.

Ambos tipos son, por supuesto, asociaciones, y en realidad no se asignan estrictamente a elementos del lenguaje como ese. La diferencia está en el propósito, el contexto y cómo se modela el sistema.

Como ejemplo práctico, compare dos tipos diferentes de sistemas con entidades similares:

• Un sistema de registro de automóviles que principalmente realiza un seguimiento de los automóviles y sus propietarios, etc. Aquí no estamos interesados ​​en el motor como una entidad separada, pero es posible que aún tengamos atributos relacionados con el motor, como la potencia y el tipo de combustible. Aquí, el motor puede ser una parte compuesta de la entidad automóvil.

• Un sistema de gestión de taller de servicio de automóviles que administra las piezas del automóvil, el servicio de los automóviles y el reemplazo de piezas, tal vez motores completos. Aquí incluso podemos tener motores almacenados y necesitamos realizar un seguimiento de ellos y otras partes por separado e independientemente de los automóviles. Aquí, el motor puede ser una parte agregada de la entidad del automóvil.

La forma en que implemente esto en su idioma es una preocupación menor, ya que en ese nivel, cosas como la legibilidad son mucho más importantes.