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 é totalmente encapsulado pelo Carro. Não há como o mundo externo obter uma referência para o Motor. O motor vive e morre com o carro. Com a agregação, o Carro também desempenha suas funções por meio de um Motor, mas o Motor nem sempre é uma parte interna do Carro. Os motores podem ser trocados ou mesmo completamente removidos. Não apenas isso, mas o mundo exterior ainda pode ter uma referência ao Motor e mexer nele, independentemente de estar no Carro.

Eu usaria um bom exemplo de UML.

Pegue uma universidade que tenha de 1 a 20 departamentos diferentes e cada departamento tenha de 1 a 5 professores. Existe um vínculo de composição entre uma Universidade e seus departamentos. Existe um vínculo 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 deverão ser destruídos. Mas não devemos matar os professores mesmo que seus respectivos departamentos desapareçam.

Em 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 em torno disso.

Há uma grande explicação no url fornecido abaixo.

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

Por favor, verifique!!!

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

Vamos definir os termos. A agregação é um metatermo no padrão UML e significa AMBOS a composição e a agregação compartilhada, simplesmente denominada compartilhada . Muitas vezes, é denominado incorretamente como "agregação". É RUIM, pois a composição também é uma agregação. Pelo que entendi, você quer dizer "compartilhado".

Mais além do padrão UML:

composto - Indica que a propriedade é agregada de forma composta, ou seja, o objeto composto é responsável pela existência e armazenamento dos objetos compostos (partes).

Então, a associação Universidade para cátedras é uma composição, porque cátedra não existe fora da universidade (IMHO)

A semântica precisa de agregação compartilhada varia por área de aplicativo e modelador.

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

Em termos simples :

Tanto a composição quanto a agregação são associações. Composição -> Relacionamento Has-A forte Agregação -> Relacionamento Has-A fraco.

Um programa de composição simples

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

    }
}

Primeiro, devemos falar sobre qual realmente é a diferença entre Aggregatione Compositionestar na mesma página.

A agregação é uma associação em que a entidade associada pode existir independentemente da associação. Por exemplo, uma pessoa pode estar associada a uma organização, mas 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 à outra e não pode existir sem a existência da outra. Na verdade, a identidade dessa entidade está sempre associada à identidade do outro objeto. Por exemplo, rodas em um carro.

Agora, a agregação pode simplesmente ser alcançada mantendo uma propriedade de uma entidade em outra como 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 objeto dependente seja sempre criado com a identidade de seu objeto associado. Você pode usar uma classe 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 cair em agregação / composição dependendo do cenário de aplicação. Por exemplo, o caso Pessoa-Organização 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 é obrigatória para inscrição. Da mesma forma, se você estiver mantendo estoque para peças de um carro, a relação carro-roda pode ser agregação.

Agregação vs Composição

A agregação implica um relacionamento em que o filho pode existir independentemente do pai. Por exemplo, Banco e Funcionário, exclua o Banco e o Funcionário ainda existe.

ao passo que Composição implica um relacionamento em que o filho não pode existir independente do pai. Exemplo: Humano e coração, coração não existem separados de um Humano.

A relação de agregação é "tem um" e a composição é uma relação "parte de".

A composição é uma associação forte, enquanto a agregação é uma associação fraca.

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

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

• Um sistema de registro de automóveis que principalmente rastreia os 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 Motor pode ser uma parte composta da entidade carro.

• Um sistema de gerenciamento de oficina automotiva que gerencia as peças do carro, faz a manutenção e troca de peças, talvez motores completos. Aqui podemos até ter motores estocados e precisarmos controlá-los e outras peças separadamente e independentemente dos carros. Aqui, o Motor pode ser uma parte agregada da entidade automóvel.

Como você implementa isso em sua linguagem é uma preocupação secundária, já que, nesse nível, coisas como a legibilidade são muito mais importantes.