Diferença de implementação entre agregação e composição em Java

Estou ciente das diferenças conceituais entre Agregação e Composição. Alguém pode me dizer a diferença de implementação em Java entre eles com exemplos?

Composição

final class Car { private final Engine engine; Car(EngineSpecs specs) { engine = new Engine(specs); } void move() { engine.work(); } } 

Agregação

 final class Car { private Engine engine; void setEngine(Engine engine) { this.engine = engine; } void move() { if (engine != null) engine.work(); } } 

No caso da composição, o motor é completamente encapsulado pelo carro. Não há como o mundo exterior obter uma referência ao mecanismo. O motor vive e morre com o carro. Com agregação, o carro também executa suas funções através de um motor, mas o motor nem sempre é uma parte interna do carro. Os motores podem ser trocados ou mesmo removidos completamente. Não só isso, mas o mundo exterior ainda pode ter uma referência ao mecanismo e mexer com ele, independentemente de estar no carro.

Eu usaria um bom exemplo de UML.

Uma universidade tem 1 a 20 departamentos diferentes e cada departamento tem de 1 a 5 professores. Há um elo de composição entre uma universidade e seus departamentos. Existe um link de agregação entre um departamento e seus professores.

A composição é apenas uma agregação FORTE, se a universidade for destruída, os departamentos também devem ser destruídos. Mas não devemos matar os professores, mesmo que seus respectivos departamentos desapareçam.

Em java:

 public class University { private List 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 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 attachedDepartments; public void destroy(){ } public void fire(Department d){ attachedDepartments.remove(d); } } 

Algo em volta disso.

Um programa simples de composição

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

A diferença é que qualquer composição é uma agregação e não vice-versa.

Vamos definir os termos. A Agregação é um metaterm no padrão UML e significa AMBOS composição e agregação compartilhada, simplesmente denominada compartilhada . Demasiadas vezes, é nomeado incorretamente “agregação”. É RUIM, pois a composição também é uma agregação. Pelo que entendi, você quer dizer “compartilhado”.

Além do padrão UML:

composite – Indica que a propriedade é agregada de forma composta, isto é, o object composto é responsável pela existência e armazenamento dos objects compostos (partes).

Então, universidade para associação de cathedras é uma composição, porque cathedra não existe fora da Universidade (IMHO)

A semântica precisa da agregação compartilhada varia de acordo com a área de aplicação e o modelador.

Ou seja, todas as outras associações podem ser desenhadas como agregações compartilhadas, se você estiver seguindo apenas alguns princípios seus ou de outra pessoa. Também olhe aqui .

Em termos simples :

Composição e Agregação são Associações. Composição -> Forte agregação de relacionamento A-A -> Fraco tem um relacionamento.

Há uma ótima explicação no URL abaixo.

insira a descrição da imagem aqui

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

Por favor, verifique!!!

Primeiro devemos falar sobre o que realmente a diferença entre Aggregation e Composition deve estar na mesma página.

Agregação é uma associação onde a entidade associada pode existir independentemente da associação. Por exemplo, uma Pessoa pode estar associada a uma Organização, mas ela pode ter existência independente no sistema.

enquanto que

Composição refere-se a uma situação em que uma das entidades associadas está fortemente relacionada com a outra e não pode existir sem a existência da outra. De fato, a identidade dessa entidade está sempre associada à identidade do outro object. Por exemplo, rodas em um carro.

Agora, a agregação pode simplesmente ser obtida mantendo uma propriedade de uma entidade em outra conforme abaixo:

 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 Composição, é necessário que o object dependente seja sempre criado com a identidade de seu object associado. Você pode usar uma class interna para o mesmo.

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

Observe que o mesmo caso de uso pode estar sujeito a agregação / composição, dependendo do cenário de aplicação. Por exemplo, o caso Person-Organization pode se tornar composição se você estiver desenvolvendo um aplicativo para pessoas que trabalham em alguma organização e a referência à organização for obrigatória para inscrição. Da mesma forma, se você está mantendo estoque para partes de um carro, o relacionamento entre rodas de carro pode ser agregação.

Ambos os tipos são, claro, associações, e não são realmente mapeados estritamente para elementos de linguagem como esse. A diferença está no propósito, no contexto e em como o sistema é modelado.

Como exemplo prático, compare dois tipos diferentes de sistemas com entidades semelhantes:

  • Um sistema de registro de carros que basicamente monitora carros e seus proprietários, etc. Aqui não estamos interessados ​​no motor como uma entidade separada, mas ainda podemos ter atributos relacionados ao motor, como potência e tipo de combustível. Aqui, o mecanismo pode ser uma parte composta da entidade automotiva.

  • Um sistema de gerenciamento de loja de serviços automotivos que gerencia peças de carros, manutenção de carros e substituição de peças, talvez motores completos. Aqui, podemos até ter motores abastecidos e precisamos rastreá-los e outras partes separadamente e independentemente dos carros. Aqui, o mecanismo pode ser uma parte agregada da entidade automotiva.

Como você implementa isso em seu idioma é de menor preocupação, já que nesse nível as coisas como legibilidade são muito mais importantes.