java - relaciones - herencia uml

Diferencia de implementación entre Agregación y Composición en Java

Question

Soy consciente de las diferencias conceptuales entre Agregación y Composición. ¿Puede alguien decirme la diferencia de implementación en Java entre ellos con ejemplos?

Answer 1

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

Vamos a establecer los términos. La Agregación es un metatermo en el estándar UML, y significa AMBAS composiciones y agregaciones compartidas, simplemente llamadas compartidas . Con demasiada frecuencia se denomina incorrectamente "agregación". Es MALO, porque la composición también es una agregación. Según entiendo, 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 es responsable 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 pueden dibujarse como agregaciones compartidas, si solo está siguiendo algunos de sus principios o los de alguien más. También mira here .

Answer 2

Ambos tipos son, por supuesto, asociaciones, y no están realmente asignados estrictamente a elementos de 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 aún podemos tener atributos relacionados con el motor, como la potencia y el tipo de combustible. Aquí el motor puede ser una parte compuesta de la entidad del automóvil.

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

La forma de implementar esto en su idioma es de menor importancia, ya que en ese nivel, cosas como la legibilidad son mucho más importantes.

Answer 3

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 automóvil. No hay forma de que el mundo exterior obtenga una referencia al motor. El motor vive y muere con el automóvil. 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 pueden intercambiarse, o incluso eliminarse 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 auto.

Answer 4

En lenguaje sencillo :

Tanto la composición como la agregación son asociaciones. Composición -> Strong Has-A relationship Aggregation -> Weak Has-A relationship.

Answer 5

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!!!

Answer 6

Primero debemos hablar acerca de qué es realmente la diferencia entre Aggregation y Composition 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 del otro. 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. Puedes 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 estar bajo agregación / composición dependiendo del 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 imprescindible para registrarse. De manera similar, si mantiene el inventario de partes de un automóvil, la relación automóvil-rueda puede ser agregada.

Answer 7

Un simple programa de Composición

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

Answer 8

Usaría un buen ejemplo UML.

Una universidad tiene de 1 a 20 departamentos diferentes y cada departamento tiene 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 la universidad es destruida, los departamentos también deberían ser destruidos. Pero no deberíamos matar a los profesores incluso si sus departamentos respetuosos 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.