Qual é a diferença entre associação, agregação e composição?

Qual é a diferença entre associação, agregação e composição? Por favor, explique em termos de implementação.

Para dois objetos, Fooe Baros relacionamentos podem ser definidos

Associação - Eu tenho um relacionamento com um objeto. FoousaBar

public class Foo { 
    void Baz(Bar bar) {
    } 
};

Composição - Possuo um objeto e sou responsável por sua vida útil. Quando Foomorre, o mesmo aconteceBar

public class Foo {
    private Bar bar = new Bar(); 
}

Agregação - Eu tenho um objeto que peguei emprestado de outra pessoa. Quando Foomorre, Barpode viver.

public class Foo { 
    private Bar bar; 
    Foo(Bar bar) { 
       this.bar = bar; 
    }
}

Eu sei que esta pergunta está marcada como c #, mas os conceitos são perguntas bastante genéricas como este redirecionamento aqui. Então, eu vou fornecer o meu ponto de vista aqui (um pouco tendencioso do ponto de vista java, onde estou mais confortável).

Quando pensamos na natureza orientada a objetos, sempre pensamos em objetos, classe (projetos de objetos) e no relacionamento entre eles. Os objetos são relacionados e interagem entre si por meio de métodos. Em outras palavras, o objeto de uma classe pode usar serviços / métodos fornecidos pelo objeto de outra classe. Esse tipo de relacionamento é denominado como associação. .

Agregação e Composição são subconjuntos de associação, o que significa que são casos específicos de associação.

• Na agregação e na composição, o objeto de uma classe "possui" o objeto de outra classe .
• Mas há uma diferença sutil. Em Composition, o objeto de classe que pertence ao objeto de sua classe não pode viver por si próprio (também chamado de "relacionamento de morte"). Ele sempre viverá como parte de seu objeto proprietário, como na Agregação, o objeto dependente é autônomo e pode existir mesmo que o objeto da classe proprietária esteja morto.
• Portanto, na composição, se o objeto proprietário for coletado de lixo, o objeto de propriedade também será o que não é o caso da agregação.

Confuso?

Exemplo de composição : considere o exemplo de um carro e um motor muito específico para esse carro (o que significa que ele não pode ser usado em nenhum outro carro). Esse tipo de relacionamento entre a classe Car e SpecificEngine é chamado Composition. Um objeto da classe Car não pode existir sem um objeto da classe SpecificEngine e o objeto SpecificEngine não tem significado sem a classe Car. Para colocar em palavras simples, a classe Car "somente" é proprietária da classe SpecificEngine.

Exemplo de agregação : Agora considere a classe Car e a classe Wheel . O carro precisa de um objeto Wheel para funcionar. Significando que o objeto Car possui o objeto Wheel, mas não podemos dizer que o objeto Wheel não tenha significado sem o objeto Car. Pode muito bem ser usado em uma bicicleta, caminhão ou objeto de carros diferentes.

Resumindo -

Para resumir, associação é um termo muito genérico usado para representar quando uma classe usa as funcionalidades fornecidas por outra classe. Dizemos que é composição se um objeto de classe pai possui outro objeto de classe filho e esse objeto de classe filho não pode existir significativamente sem o objeto de classe pai. Se puder, é chamado de agregação.

Mais detalhes aqui. Eu sou o autor de http://opensourceforgeeks.blogspot.in e adicionei um link acima à postagem relevante para obter mais contexto.

Associação é conceito generalizado de relações. Inclui composição e agregação.

A composição ( mistura ) é uma maneira de agrupar objetos simples ou tipos de dados em uma única unidade . As composições são um componente essencial de muitas estruturas básicas de dados

A agregação ( coleção ) difere da composição comum, pois não implica propriedade. Na composição, quando o objeto proprietário é destruído, o mesmo ocorre com os objetos contidos. Na agregação, isso não é necessariamente verdade.

Ambos denotam relação entre objeto e diferem apenas em sua força.

Truque para lembrar a diferença: tem A - A ggregação e O wn - c O mpositoin

Agora vamos observar a seguinte imagem

Analogia:

Composição : A imagem a seguir é a composição da imagem, ou seja, usando imagens individuais para criar uma imagem.

Agregação : coleção de imagens em um único local

Por exemplo, uma universidade possui vários departamentos e cada departamento possui vários professores. Se a universidade fechar, os departamentos não existirão mais, mas os professores desses departamentos continuarão a existir. Portanto, uma universidade pode ser vista como uma composição de departamentos, enquanto os departamentos têm uma agregação de professores. Além disso, um professor poderia trabalhar em mais de um departamento, mas um departamento não poderia fazer parte de mais de uma universidade.

Dependência (referências)
Significa que não há vínculo conceitual entre dois objetos. por exemplo, o objeto EnrollmentService faz referência a objetos Student & Course (como parâmetros de método ou tipos de retorno)

public class EnrollmentService {
    public void enroll(Student s, Course c){}
}

Associação (has-a)
Significa que quase sempre existe um link entre objetos (eles estão associados). O objeto Pedido possui um objeto Cliente

public class Order {
    private Customer customer
}

Agregação (tem-uma + parte inteira)
Tipo especial de associação em que há relação de parte inteira entre dois objetos. eles podem viver um sem o outro.

public class PlayList{
    private List<Song> songs;
}

Nota: a parte mais complicada é distinguir a agregação da associação normal. Honestamente, acho que isso está aberto a diferentes interpretações.

Composição (possui-uma + parte inteira + propriedade) Tipo
especial de agregação. Um Apartmenté composto por alguns Rooms. A Roomnão pode existir sem um Apartment. quando um apartamento é excluído, todos os quartos associados também são excluídos.

public class Apartment{
    private Room bedroom;
    public Apartment() {
       bedroom = new Room();
    }
}

De um post de Robert Martin no comp.object :

A associação representa a capacidade de uma instância enviar uma mensagem para outra instância. Isso geralmente é implementado com um ponteiro ou variável de instância de referência, embora também possa ser implementado como argumento de método ou com a criação de uma variável local.

//[Example:]

//|A|----------->|B|

class A
{
  private:
    B* itsB;
};

Agregação é o relacionamento típico de todo / parte. É exatamente o mesmo que uma associação, com a exceção de que as instâncias não podem ter relacionamentos de agregação cíclica (ou seja, uma parte não pode conter todo).

//[Example:]

//|Node|<>-------->|Node|

class Node
{
  private:
    vector<Node*> itsNodes;
};

O fato de ser uma agregação significa que as instâncias do Node não podem formar um ciclo. Portanto, essa é uma árvore de nós e não um gráfico de nós.

A composição é exatamente como Agregação, exceto que o tempo de vida da 'parte' é controlado pelo 'todo'. Esse controle pode ser direto ou transitivo. Ou seja, o 'todo' pode assumir responsabilidade direta pela criação ou destruição da 'parte', ou pode aceitar uma parte já criada e, posteriormente, passá-la para outro todo que assume a responsabilidade por ela.

//[Example:]

//|Car|<#>-------->|Carburetor|

class Car
{
  public:
    virtual ~Car() {delete itsCarb;}
  private:
    Carburetor* itsCarb
};

Como outros disseram, uma associação é uma relação entre objetos, agregação e composição são tipos de associação.

Do ponto de vista da implementação, uma agregação é obtida tendo um membro da classe por referência . Por exemplo, se a classe A agrega um objeto da classe B, você terá algo assim (em C ++):

class A {
    B & element;
  // or B * element;
};

A semântica da agregação é que, quando um objeto A é destruído, o objeto B que ele está armazenando ainda existe. Ao usar a composição, você tem um relacionamento mais forte, geralmente armazenando o membro por valor :

class A {
    B element;
};

Aqui, quando um objeto A é destruído, o objeto B que ele contém também será destruído. A maneira mais fácil de conseguir isso é armazenando o membro por valor, mas você também pode usar algum ponteiro inteligente ou excluir o membro no destruidor:

class A {
    std::auto_ptr<B> element;
};

class A {
    B * element;

    ~A() {
        delete B;
    }
};

O ponto importante é que em uma composição, o objeto contêiner possui o contido, enquanto que na agregação, ele faz referência a ele.

É incrível quanta confusão existe sobre a distinção entre os três conceitos de relacionamento : associação , agregação e composição .

Observe que os termos agregação e composição foram usados ​​na comunidade C ++, provavelmente por algum tempo antes de serem definidos como casos especiais de associação nos diagramas de classes UML.

O principal problema é o mal-entendido generalizado e contínuo (mesmo entre desenvolvedores de software especializados) de que o conceito de composição implica uma dependência do ciclo de vida entre o todo e suas partes, de modo que as partes não possam existir sem o todo, ignorando o fato de que também existem casos de associações parte-todo com partes não compartilháveis, nas quais as partes podem ser separadas e sobreviver à destruição do todo.

Tanto quanto posso ver, essa confusão tem duas raízes:

1. Na comunidade C ++, o termo "agregação" foi usado no sentido de uma classe definindo um atributo para referenciar objetos de outra classe independente (consulte, por exemplo, [1]), que é o senso de associação nos diagramas de classes UML. O termo "composição" foi usado para classes que definem objetos componentes para seus objetos, de modo que, na destruição do objeto composto, esses objetos componentes também estejam sendo destruídos.

2. Nos diagramas de classes UML, "agregação" e "composição" foram definidas como casos especiais de associações que representam relacionamentos entre parte e todo (que são discutidos na filosofia há muito tempo). Nas suas definições, a distinção entre uma "agregação" e uma "composição" se baseia no fato de permitir compartilhar uma parte entre dois ou mais conjuntos. Eles definem "composições" como tendo partes não compartilháveis ​​(exclusivas), enquanto "agregações" podem compartilhar suas partes. Além disso, eles dizem algo como o seguinte: muitas vezes, mas não em todos os casos, as composições vêm com uma dependência do ciclo de vida entre o todo e suas partes, de modo que as partes não possam existir sem o todo.

Assim, enquanto a UML colocou os termos "agregação" e "composição" no contexto certo (de relacionamentos parte-todo), eles não conseguiram defini-los de maneira clara e inequívoca, capturando as intuições dos desenvolvedores. No entanto, isso não é surpreendente, porque existem tantas propriedades diferentes (e nuances de implementação) que esses relacionamentos podem ter, e os desenvolvedores não concordam em como implementá-los.

Veja também minha resposta estendida à questão do SO de abril de 2009 listada abaixo.

E a propriedade que se supunha definir "composição" entre objetos OOP na comunidade C ++ (e essa crença ainda é amplamente aceita): a dependência do ciclo de vida em tempo de execução entre os dois objetos relacionados (o composto e seu componente) é não é realmente característico para "composição" porque podemos ter essas dependências devido à integridade referencial também em outros tipos de associações.

Por exemplo, o seguinte padrão de código para "composição" foi proposto em uma resposta do SO :

final class Car {    
  private final Engine engine;

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

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

O entrevistado afirmou que seria característico da "composição" que nenhuma outra classe pudesse fazer referência / conhecer o componente. No entanto, isso certamente não é verdade para todos os casos possíveis de "composição". Em particular, no caso do motor de um carro, o fabricante do carro, possivelmente implementado com a ajuda de outra classe, pode ter que fazer referência ao motor para poder entrar em contato com o proprietário do carro sempre que houver um problema com ele.

[1] http://www.learncpp.com/cpp-tutorial/103-aggregation/

Apêndice - Lista incompleta de perguntas repetidas sobre composição versus agregação no StackOverflow

[ Abr 2009 ]
Agregação versus composição [fechada como primariamente baseada em opiniões de]
[ Abr 2009 ]
Qual é a diferença entre o relacionamento Composição e associação?
[ Maio de 2009 ]
Diferença entre associação, agregação e composição
[ maio de 2009 ]
Qual é a diferença entre composição e agregação? [duplicado]
[ out 2009 ]
Qual é a diferença entre agregação, composição e dependência? [marcado como duplicado]
[ Nov 2010 ]
Associação x agregação [marcado como duplicado]
[Ago 2012 ]
Diferença de implementação entre agregação e composição em Java
[ fevereiro de 2015 ]
UML - associação ou agregação (trechos de código simples)

Associação

Associação representa o relacionamento entre duas classes. Pode ser unidirecional (unidirecional) ou bidirecional (bidirecional)

por exemplo:

1. unidirecional

O cliente faz pedidos

2. bidirecional

A é casado com B

B é casado com A

Agregação

A agregação é um tipo de associação.Mas com recursos específicos.A agregação é o relacionamento em uma classe "inteira" maior que contém uma ou mais classes menores de "partes". .

por exemplo:

clube tem sócios

Um clube ("todo") é composto por vários membros ("partes"). Os associados têm vida fora do clube. Se o clube ("todo") morresse, os membros ("partes") não morreriam com ele. Porque o membro pode pertencer a vários clubes ("todo").

Composição

Essa é uma forma mais forte de agregação. "Todo" é responsável pela criação ou destruição de suas "partes"

Por exemplo:

Uma escola tem departamentos

Nesse caso, a escola ("inteira") morreria, o departamento ("partes") morreria com ela. Porque cada parte pode pertencer a apenas um "todo".

É importante entender por que devemos nos preocupar em usar mais de uma vez a linha de relacionamento. O motivo mais óbvio é descrever o relacionamento pai-filho entre as classes (quando os pais excluíram todos os filhos são excluídos como resultado), mas mais impotentemente, queremos distinguir entre associação simples e composição, a fim de impor restrições implícitas à visibilidade e propagação de alterações nas classes relacionadas, uma questão que desempenha um papel importante na compreensão e redução da complexidade do sistema.

Associação

A maneira mais abstrata de descrever o relacionamento estático entre as classes é usar o link Associação, que simplesmente afirma que existe algum tipo de link ou dependência entre duas classes ou mais.

Associação fraca

A ClassA pode ser vinculada à ClassB para mostrar que um de seus métodos inclui o parâmetro da instância da ClassB ou retorna a instância da ClassB.

Associação Forte

A classe A também pode ser vinculada à classe B para mostrar que possui uma referência à instância da classe B.

Agregação (associação compartilhada)

Nos casos em que exista um relacionamento parcial entre ClassA (inteiro) e ClassB (parte), podemos ser mais específicos e usar o link de agregação em vez do link de associação, destacando que o ClassB também pode ser agregado por outras classes no aplicativo ( portanto, a agregação também é conhecida como associação compartilhada).

É importante observar que o link de agregação não indica de forma alguma que a ClassA possua a ClassB nem que exista um relacionamento pai-filho (quando o pai excluído, todos os filhos estão sendo excluídos como resultado) entre os dois. Na verdade, muito pelo contrário! O link de agregação geralmente usado para enfatizar o ponto de que ClassA não é o contêiner exclusivo da ClassB, pois na verdade a ClassB possui outro contêiner.

Agregação x associação O link de associação pode substituir o link de agregação em todas as situações, enquanto a agregação não pode substituir a associação em situações em que há apenas um 'elo fraco' entre as classes, ou seja, ClassA possui métodos que contêm parâmetros de ClassB, mas ClassA não mantenha referência à instância ClassB.

Martin Fowler sugere que o link de agregação não deve ser usado, porque não possui valor agregado e perturba a consistência, citando Jim Rumbaugh "Pense nisso como um placebo modelador".

Composição (associação não compartilhada)

Devemos ser mais específicos e usar o link de composição nos casos em que, além da parte do relacionamento entre ClassA e ClassB - há uma forte dependência do ciclo de vida entre os dois, o que significa que, quando ClassA é excluído, ClassB também é excluído como resultado.

O link de composição mostra que uma classe (contêiner, todo) possui propriedade exclusiva sobre outras classes (s), o que significa que o objeto contêiner e suas partes constituem um relacionamento pai-filho / s.

Diferentemente da associação e agregação, ao usar o relacionamento de composição, a classe composta não pode aparecer como um tipo de retorno ou tipo de parâmetro da classe composta. Portanto, as alterações na classe composta não podem se propagar para o restante do sistema. Consequentemente, o uso da composição limita o crescimento da complexidade à medida que o sistema cresce.

Medindo a complexidade do sistema

A complexidade do sistema pode ser medida simplesmente observando um diagrama de classes UML e avaliando as linhas de relacionamento de associação, agregação e composição. A maneira de medir a complexidade é determinar quantas classes podem ser afetadas pela alteração de uma determinada classe. Se a classe A expuser a classe B, qualquer classe que use a classe A poderá teoricamente ser afetada por alterações na classe B. A soma do número de classes potencialmente afetadas para cada classe no sistema é a complexidade total do sistema.

Você pode ler mais no meu blog: http://aviadezra.blogspot.com/2009/05/uml-association-aggregation-composition.html

Composição (se você remover "inteiro", a "parte" também será removida automaticamente - "Propriedade")

• Crie objetos da sua classe existente dentro da nova classe. Isso se chama composição porque a nova classe é composta de objetos de classes existentes.

• Normalmente, use variáveis ​​de membro normais.

• Pode usar valores de ponteiro se a classe de composição manipular automaticamente a alocação / desalocação responsável pela criação / destruição de subclasses.

Composição em C ++

#include <iostream>
using namespace std;
/********************** Engine Class ******************/
class Engine
{
    int nEngineNumber;
    public:
    Engine(int nEngineNo);
    ~Engine(void);
};
Engine::Engine(int nEngineNo)
{
    cout<<" Engine :: Constructor " <<endl;
}
Engine::~Engine(void)
{
    cout<<" Engine :: Destructor " <<endl;
}
/********************** Car Class ******************/
class Car
{
    int nCarColorNumber;
    int nCarModelNumber;
    Engine objEngine;
    public:
    Car (int, int,int);
    ~Car(void);
};
Car::Car(int nModelNo,int nColorNo, int nEngineNo):
nCarModelNumber(nModelNo),nCarColorNumber(nColorNo),objEngine(nEngineNo)
{
    cout<<" Car :: Constructor " <<endl;
}
Car::~Car(void)
{
    cout<<" Car :: Destructor " <<endl;
    Car
    Engine
    Figure 1 : Composition
}
/********************** Bus Class ******************/
class Bus
{
    int nBusColorNumber;
    int nBusModelNumber;
    Engine* ptrEngine;
    public:
    Bus(int,int,int);
    ~Bus(void);
};
Bus::Bus(int nModelNo,int nColorNo, int nEngineNo):
nBusModelNumber(nModelNo),nBusColorNumber(nColorNo)
{
    ptrEngine = new Engine(nEngineNo);
    cout<<" Bus :: Constructor " <<endl;
}
Bus::~Bus(void)
{
    cout<<" Bus :: Destructor " <<endl;
    delete ptrEngine;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    // Composition using simple Engine in a car object
    {
        cout<<"------------- Inside Car Block ------------------"<<endl;
        Car objCar (1, 2,3);
    }
    cout<<"------------- Out of Car Block ------------------"<<endl;
    // Composition using pointer of Engine in a Bus object
    {
        cout<<"------------- Inside Bus Block ------------------"<<endl;
        Bus objBus(11, 22,33);
    }
    cout<<"------------- Out of Bus Block ------------------"<<endl;
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

Resultado

--------------- Start Of Program --------------------
------------- Inside Car Block ------------------
Engine :: Constructor
Car :: Constructor
Car :: Destructor
Engine :: Destructor
------------- Out of Car Block ------------------
------------- Inside Bus Block ------------------
Engine :: Constructor
Bus :: Constructor
Bus :: Destructor
Engine :: Destructor
------------- Out of Bus Block ------------------
--------------- End Of Program --------------------

Agregação (se você remover "todo", poderá existir "Parte" - "Sem propriedade")

• Uma agregação é um tipo específico de composição em que não está implícita a propriedade entre o objeto complexo e os subobjetos. Quando um agregado é destruído, os subobjetos não são destruídos.

• Normalmente, use variáveis ​​de ponteiro / variável de referência que apontam para um objeto que vive fora do escopo da classe agregada

• Pode usar valores de referência que apontam para um objeto que vive fora do escopo da classe agregada

• Não nos responsabilizamos por criar / destruir subclasses

Código de agregação em C ++

#include <iostream>
#include <string>
using namespace std;
/********************** Teacher Class ******************/
class Teacher
{
    private:
    string m_strName;
    public:
    Teacher(string strName);
    ~Teacher(void);
    string GetName();
};
Teacher::Teacher(string strName) : m_strName(strName)
{
    cout<<" Teacher :: Constructor --- Teacher Name :: "<<m_strName<<endl;
}
Teacher::~Teacher(void)
{
    cout<<" Teacher :: Destructor --- Teacher Name :: "<<m_strName<<endl;
}
string Teacher::GetName()
{
    return m_strName;
}
/********************** Department Class ******************/
class Department
{
    private:
    Teacher *m_pcTeacher;
    Teacher& m_refTeacher;
    public:
    Department(Teacher *pcTeacher, Teacher& objTeacher);
    ~Department(void);
};
Department::Department(Teacher *pcTeacher, Teacher& objTeacher)
: m_pcTeacher(pcTeacher), m_refTeacher(objTeacher)
{
    cout<<" Department :: Constructor " <<endl;
}
Department::~Department(void)
{
    cout<<" Department :: Destructor " <<endl;
}
/********************** Main Function ******************/
int main()
{
    freopen ("InstallationDump.Log", "w", stdout);
    cout<<"--------------- Start Of Program --------------------"<<endl;
    {
        // Create a teacher outside the scope of the Department
        Teacher objTeacher("Reference Teacher");
        Teacher *pTeacher = new Teacher("Pointer Teacher"); // create a teacher
        {
            cout<<"------------- Inside Block ------------------"<<endl;
            // Create a department and use the constructor parameter to pass the teacher to it.
            Department cDept(pTeacher,objTeacher);
            Department
            Teacher
            Figure 2: Aggregation
        } // cDept goes out of scope here and is destroyed
        cout<<"------------- Out of Block ------------------"<<endl;
        // pTeacher still exists here because cDept did not destroy it
        delete pTeacher;
    }
    cout<<"--------------- End Of Program --------------------"<<endl;
    fclose (stdout);
}

Resultado

--------------- Start Of Program --------------------
Teacher :: Constructor --- Teacher Name :: Reference Teacher
Teacher :: Constructor --- Teacher Name :: Pointer Teacher
------------- Inside Block ------------------
Department :: Constructor
Department :: Destructor
------------- Out of Block ------------------
Teacher :: Destructor --- Teacher Name :: Pointer Teacher
Teacher :: Destructor --- Teacher Name :: Reference Teacher
--------------- End Of Program --------------------

O problema com essas respostas é que elas são metade da história: elas explicam que agregação e composição são formas de associação, mas não dizem se é possível que uma associação não seja uma delas.

Eu entendo com base em algumas breves leituras de muitas postagens sobre SO e alguns documentos da UML que existem quatro principais formas concretas de associação de classe:

1. composição: A é composto por um B; B não existe sem A, como um quarto em uma casa
2. agregação: A has-a B; B pode existir sem A, como um aluno em uma sala de aula
3. dependência: A usa-a B; nenhuma dependência do ciclo de vida entre A e B, como um parâmetro de chamada de método, valor de retorno ou um temporário criado durante uma chamada de método
4. generalização: A é-a B

Quando um relacionamento entre duas entidades não é um deles, ele pode ser chamado de "uma associação" no sentido genérico do termo, além de descrever outras formas (nota, estereótipo, etc.).

Meu palpite é que a "associação genérica" ​​se destina a ser usada principalmente em duas circunstâncias:

• quando as especificidades de um relacionamento ainda estão sendo elaboradas; esse relacionamento em um diagrama deve ser convertido o mais rápido possível para o que realmente é / será (um dos outros 4).
• quando um relacionamento não corresponde a nenhum dos quatro predeterminados pela UML; a associação "genérica" ​​ainda oferece uma maneira de representar um relacionamento que "não é um dos outros", para que você não fique preso usando um relacionamento incorreto com uma nota "isso não é realmente agregação, é apenas que UML não tem nenhum outro símbolo que possamos usar "

Acho que este link fará sua lição de casa: http://ootips.org/uml-hasa.html

Para entender os termos, lembro-me de um exemplo nos meus primeiros dias de programação:

Se você tiver um objeto 'tabuleiro de xadrez' que contenha objetos 'caixa' que sejam composição, porque se o 'tabuleiro de xadrez' for excluído, não haverá mais razão para as caixas existirem.

Se você tiver um objeto 'quadrado' com um objeto 'cor' e o quadrado for excluído, o objeto 'cor' ainda poderá existir, ou seja, agregação

Ambos são associações , a principal diferença é conceitual

Composição : É aqui que, quando você destrói um objeto (Escola), outro objeto (Sala de Aula) que está vinculado a ele também é destruído. Ambos não podem existir independentemente.

Agregação : isso é exatamente o oposto da Compositionassociação acima ( ), onde uma vez que você mata um objeto ( Company), o outro objeto ( Employees) que está vinculado a ele pode existir por si próprio.

Associação .
Composição e agregação são as duas formas de associação.

    Simple rules:
    A "owns" B = Composition : B has no meaning or purpose in the system 
    without A
    A "uses" B = Aggregation : B exists independently (conceptually) from A
    A "belongs/Have" B= Association; And B exists just have a relation
    Example 1:

    A Company is an aggregation of Employees.
    A Company is a composition of Accounts. When a Company ceases to do 
    business its Accounts cease to exist but its People continue to exist. 
    Employees have association relationship with each other.

    Example 2: (very simplified)
    A Text Editor owns a Buffer (composition). A Text Editor uses a File 
    (aggregation). When the Text Editor is closed,
    the Buffer is destroyed but the File itself is not destroyed.

Em uma frase muito simples:
Agregação e Composição são subconjuntos de associação.

• A usa B -> isso é uma agregação

• A precisa B -> é composição.

Leia mais aqui .

Gostaria de ilustrar como os três termos são implementados no Rails. O ActiveRecord chama qualquer tipo de relacionamento entre dois modelos an association. Não se encontra com muita frequência os termos compositione aggregation, ao ler a documentação ou os artigos, relacionados ao ActiveRecord. Uma associação é criada adicionando uma das macros da classe de associação ao corpo da classe. Alguns desses macros são belongs_to, has_one, has_manyetc ..

Se queremos configurar um compositionou aggregation, precisamos adicionar belongs_toao modelo de propriedade (também chamado de filho) e / has_oneou has_manyao modelo de propriedade (também chamado de pai). Se configuramos compositionou aggregationdepende das opções que passamos para a belongs_tochamada no modelo filho. Antes do Rails 5, configurando belongs_tosem nenhuma opção criada aggregation, o filho poderia existir sem um pai. Se quisermos um composition, precisamos declarar explicitamente isso adicionando a opção required: true:

class Room < ActiveRecord::Base
  belongs_to :house, required: true
end

No Rails 5, isso foi alterado. Agora, declarar uma belongs_toassociação cria um compositionpor padrão, o filho não pode existir sem um pai. Portanto, o exemplo acima pode ser reescrito como:

class Room < ApplicationRecord
  belongs_to :house
end

Se queremos permitir que o objeto filho exista sem um pai, precisamos declarar isso explicitamente através da opção optional

class Product < ApplicationRecord
  belongs_to :category, optional: true
end

De: Remo H. Jansen, livro “Beginning React: Learning TypeScript 2.x - Second Edition”:

Chamamos de associação aquelas relações cujos objetos têm um ciclo de vida independente, onde não há propriedade dos objetos. Vamos dar uma olhada em um exemplo de professor e aluno. Vários alunos podem ser associados a um único professor, e um único aluno pode ser associado a vários professores, mas ambos têm ciclos de vida independentes (ambos podem criar e excluir independentemente). Portanto, quando um professor sai da escola, não precisamos excluir nenhum aluno e, quando um aluno sai da escola, não precisamos excluir nenhum professor.

Chamamos agregação de relacionamentos cujos objetos têm um ciclo de vida independente, mas existe propriedade e os objetos filhos não podem pertencer a outro objeto pai. Vamos dar um exemplo de um telefone celular e uma bateria de telefone celular. Uma única bateria pode pertencer a um telefone, mas se o telefone parar de funcionar e a excluirmos do nosso banco de dados, a bateria do telefone não será excluída porque ainda pode estar funcionando. Então, na agregação, enquanto existe propriedade, os objetos têm seu ciclo de vida

Usamos o termo composição para nos referir a relacionamentos cujos objetos não possuem um ciclo de vida independente e, se o objeto pai for excluído, todos os objetos filhos também serão excluídos. Vamos dar um exemplo da relação entre perguntas e respostas. Perguntas simples podem ter várias respostas, e as respostas não podem pertencer a várias perguntas. Se excluirmos perguntas, as respostas serão excluídas automaticamente.

Associação é um relacionamento entre duas classes separadas e a associação pode ser de qualquer tipo, por exemplo, uma para uma, uma para maio, etc. Ela une duas entidades totalmente separadas.

A agregação é uma forma especial de associação que é um relacionamento unidirecional unidirecional entre classes (ou entidades), por exemplo, classes Wallet e Money. A Carteira possui dinheiro, mas o dinheiro não precisa necessariamente da Carteira, portanto, é um relacionamento unidirecional. Nesse relacionamento, ambas as entradas podem sobreviver se outra terminar. No nosso exemplo, se a classe Wallet não estiver presente, isso não significa que a classe Money não possa existir.

A composição é uma forma restrita de agregação, na qual duas entidades (ou você pode dizer classes) são altamente dependentes uma da outra. Por exemplo, humano e coração. Um humano precisa de coração para viver e um coração precisa de um corpo humano para sobreviver. Em outras palavras, quando as classes (entidades) são dependentes uma da outra e sua vida útil é a mesma (se uma morre e outra também), então é uma composição. A classe cardíaca não faz sentido se a classe humana não estiver presente.

https://www.linkedin.com/pulse/types-relationships-object-oriented-programming-oop-sarah-el-dawody/

Composição: é um relacionamento "parte de".

por exemplo "o motor faz parte do carro", "o coração faz parte do corpo".

Associação: é um relacionamento do tipo "tem um"

Por exemplo, suponha que tenhamos duas classes, então essas duas classes são consideradas como "tem um" se essas duas entidades compartilharem o objeto uma da outra para algum trabalho e, ao mesmo tempo, existirem sem a dependência uma da outra ou ambas tiverem o seu própria vida.

O exemplo acima mostra um relacionamento de associação por causa da classe Employee e Manager usando o objeto um do outro e seu próprio ciclo de vida independente.

Agregação: baseia-se no relacionamento "tem-a" e é \\ uma forma especial de associação

por exemplo, "Aluno" e "endereço". Cada aluno deve ter um endereço para que o relacionamento entre a turma do Aluno e a turma do Endereço seja do tipo "Has-A", mas vice-versa não é verdadeiro.