What is the difference between association, aggregation and composition?

Question

What is the difference between association, aggregation, and composition? Please explain in terms of implementation.

Whoop

I should also add, in UML 2 there is no such Element as Aggregation or Composition (it was in UML 1.4 though). In UML 2, aggregation/compositions are implemented as Association elements with the AggregationKind property set to either Shared or Composite. – Amerce

Lots of answers on SO already: stackoverflow.com/search?q=aggregation+and+composition – Selfhood

useful article here codeproject.com/Articles/22769/… – Colic

I know this has already been answered many times, but I feel the best explanation I've ever read on the matter is this one: holub.com/goodies/uml/#composition – Beshrew

When we have any relation between objects, that is called Association. Aggregation and Composition both are specialized form of Association. Composition is again specialize form of Aggregation. javabench.in/2011/08/difference-between-association.html – Remainderman

It's no surprise that there is so much confusion. Answer could be very concise and contain snippets but here comes an issue: it seems that different languages have different approach to these concepts. What I know after reading below answers is: Composition is kind of Aggregation and Aggregation is kind of Association and difference between Composition and Aggregation is that in Composition composed object dies together with its "parent". There is no answer which describes clearly difference between Aggregation and Association. In most cases the same snippet is used for both of them. – Otto

Answer 1

For two objects, Foo and Bar the relationships can be defined

Association - I have a relationship with an object. Foo uses Bar

public class Foo {         
    private Bar bar;
};

NB: See Fowler's definition - the key is that Bar is semantically related to Foo rather than just a dependency (like an int or string).

Composition - I own an object and I am responsible for its lifetime. When Foo dies, so does Bar

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

Aggregation - I have an object which I've borrowed from someone else. When Foo dies, Bar may live on.

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

Catholicize

Seems C#/Java code. If that's the case, both Association and Aggregation code are same. In both cases, 'bar' is just referenced and Bar object may live on. – Spiker

@Jeff Foster: I have some doubts. If I instantiate bar object in Baz(Bar bar){bar=new Bar(); } in first case. Will it still be association or will it become composition now? – Varletry

@Ajay: Aggregation keeps the reference of the objects which is not the case with association. Hence the difference of implementation. – Siana

Association is a bit stronger than just usage as a method parameter. I believe your association code snippet corresponds more to a Dependency relation. you might want to check Martin Fowler related article – Nottingham

@AhmadAbdelghany is correct. First example is a dependency relation. The third one works for association and aggregation. – Disenfranchise

Sorry but the example for the association is not an association, but a simple usage dependency. An association implies the existence of a semantic relationship i.e. links associating concrete instances. – Topographer

What Christophe said. Further the Aggregation is wrong since UML 2.5 which defines that there is no defined semantics and needs to be defined in the modeling domain. – Slapjack

The Association example can cause many confusions! I hope that CS students are wise enough to check this comment section too. It's very misleading. – Horde

@Jeff Foster For the first example, the Foo is responsible for lifetime of Bar. So why it not composition? – Wept

Answer 2

I know this question is tagged as C# but the concepts are pretty generic questions like this redirect here. So I am going to provide my point of view here (a bit biased from java point of view where I am more comfortable).

When we think of Object-oriented nature we always think of Objects, class (objects blueprints) and the relationship between them. Objects are related and interact with each other via methods. In other words the object of one class may use services/methods provided by the object of another class. This kind of relationship is termed as association..

Aggregation and Composition are subsets of association meaning they are specific cases of association.

• In both aggregation and composition object of one class "owns" object of another class.
• But there is a subtle difference. In Composition the object of class that is owned by the object of it's owning class cannot live on it's own(Also called "death relationship"). It will always live as a part of it's owning object where as in Aggregation the dependent object is standalone and can exist even if the object of owning class is dead.
• So in composition if owning object is garbage collected the owned object will also be which is not the case in aggregation.

Confused?

Composition Example : Consider the example of a Car and an engine that is very specific to that car (meaning it cannot be used in any other car). This type of relationship between Car and SpecificEngine class is called Composition. An object of the Car class cannot exist without an object of SpecificEngine class and object of SpecificEngine has no significance without Car class. To put in simple words Car class solely "owns" the SpecificEngine class.

Aggregation Example : Now consider class Car and class Wheel. Car needs a Wheel object to function. Meaning the Car object owns the Wheel object but we cannot say the Wheel object has no significance without the Car Object. It can very well be used in a Bike, Truck or different Cars Object.

Summing it up -

To sum it up association is a very generic term used to represent when a class uses the functionalities provided by another class. We say it's composition if one parent class object owns another child class object and that child class object cannot meaningfully exist without the parent class object. If it can then it is called Aggregation.

More details here. I am the author of http://opensourceforgeeks.blogspot.in and have added a link above to the relevant post for more context.

Bleier

I was going to ask why you cared to answer an already answered question that was asked more than 5 years ago but then I read your blog entry and it was way more informative than some of the answers here. Upvoted! – Oxy

I agree with @Oxy your answer is way more informative and correct than many others – Cornu

It's really funny when C# and Java developers claim they use composition when it only exists on primitive types with those languages. If you want to really understand composition you have to use C++ where objects can REALLY be part of other objects.. Not just floating in heap memory and holding pointers to each other and claiming there is composition.. – Parada

@Parada i arrived at the same conclusion as you, but i'm not so sure of it. For example, say i have one class that is semantically owned by one specific class, however the owned object is garbage collected after its owner has already been removed by the garbage collector, is it considered a composition? – Passport

Can we have composition within a c# code using managed memory? – Passport

death relationship - scary name but easy to remember for composition relationship. – Shirr

@Everyone, unless I'm misunderstanding your point (don't follow how "primitive types" come into this), that sounds like a distinction without a difference. Whether an object is properly within another, or it lives in a random place on the heap, or you don't have to care because garbage collection, it is all conceptually identical in the context of relationships. If we're talking object design here, composition is composition. – Griddlecake

@Griddlecake it isn't conceptually identical, it's very different. What you mentioned has a name, it's aggregation where one object holds a reference to another. Aggregation and composition are conceptually different. In C++, a composed object is one that cannot outlive its composer. In Java and C#, you can destroy the "composer" and the "composed" can still live if something else holds its reference. – Parada

@Everyone, design patterns may be implemented somewhat differently depending on language, of course, but their utility as "design patterns" are necessarily derived from remaining substantially implementation-agnostic. Composition always and by definition implies lifetime management by or via the container. The C#/Java scenario you describe could either just be aggregation, where someone else owns the "composed" object, or else it's a faulty implementation due to breaking encapsulation, which is every bit as possible in C++ (exposing a pointer to the owned object, for example). – Griddlecake

@Griddlecake the main difference in C++ and C#/Java in this regard is that when a reference to the composed object is shared in C++, it will invalidate after the composer is destroyed. In C# and Java, GC decides when things die or when they don't. You do not have such control. So if a reference to the composed is held anywhere, it will outlive its composer upon the latter's destruction. Whether or not it breaks encapsulation is a different topic. The bottom line is: you cannot ensure composed's destruction in C#/Java with its composer. Therefore, it can't be composition, but instead aggregation. – Parada

@Everyone, again, if anyone is holding a reference to a purportedly owned object, it isn't really owned and, consequently, was never an example of composition to begin with. No point repeating myself beyond that, so agree to disagree, I guess... – Griddlecake

@Griddlecake we can agree to disagree. I don't think C#/Java can have proper composition as the one C++ offers. That's what I said from the get-go. – Parada

Is the relationship between an Album and its Tracks a composition? Or an aggregation? How about a Band and its members? – Pyrology

If you answer using Java as an example then wouldn't it be good to clarify whether by composition you mean: a) class A and class B (where class B is an inner class of class A and therefore it LITERALLY cannot exist without B) or b) you mean that it cannot exist without A in "domain" sense but it perfectly can exist in terms of code (if we really want we can do "new B()" without the instance of A class) ? – Otto

Answer 3

Association is generalized concept of relations between objects.

Composition(mixture) is a way to wrap simple objects or data types into a single unit. Compositions are a critical building block of many basic data structures

Aggregation(The formation of a number of things into a cluster) differs from ordinary composition in that it does not imply ownership. In composition, when the owning object is destroyed, so are the contained objects. In aggregation, this is not necessarily true.

Trick to remember the difference :

• "can-call": Association
• "Has-A": Aggregation
• "Part-Of": comPOsition

context	Aggregation	Composition
Life time	objects have their own lifetime and there is no owner	controlled by whole or parent that owns it
Scope	parent objects and child objects are independent	parent object also means the death of its children.
Relationship	Has-a	Part-of
Strength	weak relationship	strong relationship.
Real-life example	Car and Driver	Car and wheels

Now let observe the following image

Association / Aggregation / Composition (Tight Coupling): Use a solid line with an association arrow between the classes. This represents a general relationship between classes, and changes in one class can directly impact the other. You can also use association end multiplicity to indicate the nature and cardinality of the relationship.

Dependency / Interface or Abstract Class (Loose Coupling): You can use a dashed line with an arrow pointing from one class to another. This indicates that one class depends on the other in some way. Dependencies can be tight if changes in the supplier class directly affect the client class

Analogy:

Composition: The following picture is image composition i.e. using individual images making one image.

Aggregation : collection of image in single location

For example, A university owns various departments, and each department has a number of professors. If the university closes, the departments will no longer exist, but the professors in those departments will continue to exist. Therefore, a University can be seen as a composition of departments, whereas departments have an aggregation of professors. In addition, a Professor could work in more than one department, but a department could not be part of more than one university.

Puce

After reading so much on this topic, this answer is the most intuitive understandable one. Should be put on wikipedia. – Recrudesce

With regard to aggregation, you say "Child objects belong to a single parent". This is not correct. It is valid UML to have shared aggregation, i.e. a child belongs to multiple parents. You acknowledge this in your example about Department as an aggregation of Professors, because you say that a Professor can work for more than one Department. – Mira

@Mira AFAIK shared aggregation does not mean "a child belongs to multiple parents", it's just the other way round, multiple children belong to the same parents. And it's a non-composite aggregation because even if the parents die, the children may survive longer. – Oneal

@Oneal No, shared aggregation means the child (part) is shared by multiple parents (whole), so www.admiraalit.nl is right: this answer is incorrect. – Kendallkendell

In your table you say that composition is "part of", while aggregation is "has a". This doesn't sound right, as it would mean "A is part of B", or "Car is part of wheels". You're not keeping what side the subject is on consistent. – Outfall

@Puce The names of your UML notations image are not the standard UML names for these relations. Inheritance => Generalization, Realize/Implimentation => Realization. Also you have a few spelling errors in Implimentation and Dependancy – Agglutinogen

youtube.com/watch?v=j84w5VM9GT8 – Puce

Answer 4

Dependency (references)
It means there is no conceptual link between two objects. e.g. EnrollmentService object references Student & Course objects (as method parameters or return types)

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

Association (has-a)
It means there is almost always a link between objects (they are associated). Order object has a Customer object

public class Order {
    private Customer customer
}

Aggregation (has-a + whole-part)
A special kind of association where there is whole-part relation between two objects. they might live without each other though.

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

OR

public class Computer {
    private Monitor monitor;
}

Note: the trickiest part is to distinguish aggregation from normal association. Honestly, I think this is open to different interpretations.

Composition (has-a + whole-part + ownership)
A special kind of aggregation. An Apartment is composed of some Rooms. A Room cannot exist without an Apartment. when an apartment is deleted, all associated rooms are deleted as well.

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

Nottingham

Yup, the only tricky part in determining object relationships is to distinguish between Association and Aggregation. Everything else is clear. +1 from me – Owe

Mustn't aggregation & association be the same from the implementation POV, since the only difference is logically ? I think the aggregation AND association CAN have collection-like containers as references, since this is something that usually is decided by multiplicity, not really related to the relationship type. – Pilferage

@AhmedAlhallag True, they are both implemented the same way i.e. "has-a". I never meant to say that aggregation always uses collections. I will try to come up with another example that isn't using collections to avoid confusion. Thanks. – Nottingham

@AhmadAbdelghany Thank you for clarification and for your efforts nonetheless. – Pilferage

This helped me the most from an implementation perspective. Thanks! – Seldun

Answer 5

As others said, an association is a relationship between objects, aggregation and composition are types of association.

From an implementation point of view, an aggregation is obtained by having a class member by reference. For example, if class A aggregates an object of class B, you'll have something like this (in C++):

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

The semantics of aggregation is that when an object A is destroyed, the B object it is storing will still exists. When using composition, you have a stronger relationship, usually by storing the member by value:

class A {
    B element;
};

Here, when an A object is destroyed, the B object it contains will be destroyed too. The easiest way to achieve this is by storing the member by value, but you could also use some smart pointer, or delete the member in the destructor:

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

class A {
    B * element;

    ~A() {
        delete B;
    }
};

The important point is that in a composition, the container object owns the contained one, whereas in aggregation, it references it.

Glendaglenden

This should be the only accepted answer. Composition does not exist in C# and Java except with primitive types... Yet you see developers of those languages "explaining" composition. Composition means an object exists INSIDE another. In Java and C# you cant even do it, everything is on the heap and you just hold pointer to it, it is really aggregation not composition. C++ provides composition.. – Parada

after a good while of looking around, I think this is the most and only accurate answer to this subject – Pilferage

Answer 6

From a post by Robert Martin in comp.object:

Association represents the ability of one instance to send a message to another instance. This is typically implemented with a pointer or reference instance variable, although it might also be implemented as a method argument, or the creation of a local variable.

//[Example:]

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

class A
{
  private:
    B* itsB;
};

Aggregation [...] is the typical whole/part relationship. This is exactly the same as an association with the exception that instances cannot have cyclic aggregation relationships (i.e. a part cannot contain its whole).

//[Example:]

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

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

The fact that this is aggregation means that the instances of Node cannot form a cycle. Thus, this is a Tree of Nodes not a graph of Nodes.

Composition [...] is exactly like Aggregation except that the lifetime of the 'part' is controlled by the 'whole'. This control may be direct or transitive. That is, the 'whole' may take direct responsibility for creating or destroying the 'part', or it may accept an already created part, and later pass it on to some other whole that assumes responsibility for it.

//[Example:]

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

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

Embankment

How much authority does this definition have? Is it supported by the UML standard authors? I it supported by tools? – Raffish

It's the Robert C. Martin. That's enough authority for me :-) – Feuchtwanger

Answer 7

It's amazing how much confusion exists about the distinction between the three relationship concepts association, aggregation and composition.

Notice that the terms aggregation and composition have been used in the C++ community, probably for some time before they have been defined as special cases of association in UML Class Diagrams.

The main problem is the widespread and ongoing misunderstanding (even among expert software developers) that the concept of composition implies a life-cycle dependency between the whole and its parts such that the parts cannot exist without the whole, ignoring the fact that there are also cases of part-whole-associations with non-shareable parts where the parts can be detached from, and survive the destruction of, the whole.

As far as I can see, this confusion has two roots:

1. In the C++ community, the term "aggregation" was used in the sense of a class defining an attribute for referencing objects of another independent class (see, e.g., [1]), which is the sense of association in UML Class Diagrams. The term "composition" was used for classes that define component objects for their objects, such that on destruction of the composite object, these component objects are being destroyed as well.

2. In UML Class Diagrams, both "aggregation" and "composition" have been defined as special cases of associations representing part-whole relationships (which have been discussed in philosophy for a long time). In their definitions, the distinction between an "aggregation" and a "composition" is based on the fact if it allows sharing a part between two or more wholes. They define "compositions" as having non-shareable (exclusive) parts, while "aggregations" may share their parts. In addition they say something like the following: very often, but not in all cases, compositions come with a life-cycle dependency between the whole and its parts such that the parts cannot exist without the whole.

Thus, while UML has put the terms "aggregation" and "composition" in the right context (of part-whole relationships), they have not managed to define them in a clear and unambiguous manner, capturing the intuitions of developers. However, this is not surprising because there are so many different properties (and implementation nuances) these relationships can have, and developers do not agree on how to implement them.

See also my extended answer to the SO question of Apr 2009 listed below.

And the property that was assumed to define "composition" between OOP objects in the C++ community (and this belief is still widely held): the run-time life-cycle dependency between the two related objects (the composite and its component), is not really characteristic for "composition" because we can have such dependencies due to referential integrity also in other types of associations.

For instance, the following code pattern for "composition" was proposed in an SO answer:

final class Car {    
  private final Engine engine;

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

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

The respondent claimed that it would be characteristic for "composition" that no other class could reference/know the component. However, this is certainly not true for all possible cases of "composition". In particular, in the case of a car's engine, the maker of the car, possibly implemented with the help of another class, may have to reference the engine for being able to contact the car's owner whenever there is an issue with it.

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

Appendix - Incomplete list of repeatedly asked questions about composition versus aggregation on StackOverflow

[Apr 2009]
Aggregation versus Composition [closed as primarily opinion-based by]
[Apr 2009]
What is the difference between Composition and Association relationship?
[May 2009]
Difference between association, aggregation and composition
[May 2009]
What is the difference between composition and aggregation? [duplicate]
[Oct 2009]
What is the difference between aggregation, composition and dependency? [marked as duplicate]
[Nov 2010]
Association vs. Aggregation [marked as duplicate]
[Aug 2012]
Implementation difference between Aggregation and Composition in Java
[Feb 2015]
UML - association or aggregation (simple code snippets)

Burdette

upvote for the incomplete list of repeatedly asked questions. – Gilgilba

Answer 8

Association

Association represents the relationship between two classes.It can be unidirectional(one way) or bidirectional(two way)

for example:

1. unidirectional

Customer places orders

2. bidirectional

A is married to B

B is married to A

Aggregation

Aggregation is a kind of association.But with specific features.Aggregation is the relationship in one larger "whole" class contains one or more smaller "parts" classes.Conversely, a smaller "part" class is a part of "whole" larger class.

for example:

club has members

A club("whole") is made up of several club members("parts").Member have life to outside the club. If the club("whole") were to die, members("parts") would not die with it. Because member can belong to multiple clubs("whole").

Composition

This is a stronger form of aggregation."Whole" is responsible for the creation or destruction of its "parts"

For example:

A school has departments

In this case school("whole") were to die, department("parts") would die with it. Because each part can belong to only one "whole".

Billfish

In case of agregation. Should i use class Club(){ _member = new Member } or pass it as reference class Club(){ addMember(Member member) { this._member = member } } – Woken

Interesting. But I’m confused about your notion of unidirectional vs bidirectional. For example, when dealing with an order, the association with the customer is needed to find the name to print on the label, and conversely, when dealing with a customer one need to know about the orders. Isn’t it the same relation that is used in two directions? – Topographer

Answer 9

Association, Aggregation, Composition

Association, Aggregation, Composition are about Has a relationship.

Aggregation and Composition are subsets of Association which describe relationship more accurately

Aggregation - independent relationship. An object can be passed and saved inside class via constructor, method, setter...

Composition - dependent relationship. An object is created by owner object

*Association is an alternative for sybtyping

Snotty

Answer 10

It's important to understand why we should even bother with using more than once relationship line. The most obvious reason is to describe parent-child relationship between classes (when parent deleted all its child’s are deleted as a result), but more impotently, we want to distinguish between simple association and composition in order to place implicit restrictions on the visibility and propagation of changes to the related classes, a matter which plays an important role in understanding and reducing system complexity.

Association

The most abstract way to describe static relationship between classes is using the Association link, which simply states that there is some kind of a link or a dependency between two classes or more.

Weak Association

ClassA may be linked to ClassB in order to show that one of its methods includes parameter of ClassB instance, or returns instance of ClassB.

Strong Association

ClassA may also be linked to ClassB in order to show that it holds a reference to ClassB instance.

Aggregation (Shared Association)

In cases where there’s a part-of relationship between ClassA (whole) and ClassB (part), we can be more specific and use the aggregation link instead of the association link, highlighting that ClassB can also be aggregated by other classes in the application (therefore aggregation is also known as shared association).

It’s important to note that the aggregation link doesn’t state in any way that ClassA owns ClassB nor that there’s a parent-child relationship (when parent deleted all its child’s are being deleted as a result) between the two. Actually, quite the opposite! The aggregation link usually used to stress the point that ClassA is not the exclusive container of ClassB, as in fact ClassB has another container.

Aggregation v.s. Association The association link can replace the aggregation link in every situation, while aggregation cannot replace association in situations where there’s only a ‘weak link’ between the classes, i.e. ClassA has method/s that contain parameter of ClassB but ClassA doesn’t hold reference to ClassB instance.

Martin Fowler suggest that the aggregation link should not be used at all because it has no added value and it disturb consistency, Quoting Jim Rumbaugh "Think of it as a modeling placebo".

Composition (Not-Shared Association)

We should be more specific and use the composition link in cases where in addition to the part-of relationship between ClassA and ClassB - there’s a strong lifecycle dependency between the two, meaning that when ClassA is deleted then ClassB is also deleted as a result

The composition link shows that a class (container, whole) has exclusive ownership over other class/s (parts), meaning that the container object and its parts constitute a parent-child/s relationship.

Unlike association and aggregation, when using the composition relationship, the composed class cannot appear as a return type or parameter type of the composite class. Thus, changes to the composed class cannot propagate to the rest of the system. Consequently, usage of composition limits complexity growth as the system grows.

Measuring system complexity

System complexity can be measured simply by looking at a UML class diagram and evaluating the association, aggregation, and composition relationship lines. The way to measure complexity is to determine how many classes can be affected by changing a particular class. If class A exposes class B, then any given class that uses class A can theoretically be affected by changes to class B. The sum of the number of potentially affected classes for every class in the system is the total system complexity.

You can read more on my blog: http://aviadezra.blogspot.com/2009/05/uml-association-aggregation-composition.html

---

Wrinkle

Good answer. 1) Question for the composition example: Leng and Hand (composition) Person. if i create a class Animal and Sleep then Sleep (agregation) Person; Sleep (agregation) Animal. Is it correct? 2). Hand composition Person: class Person() { private hand = new Hand }. Sleep agregation Person class Person() { private sleep = new Sleep } Is valid use the key "new" in Sleep? or should i pass it as reference because is agregation? class Person() { private Sleep _sleep; public addSleep(Sleep sleep) { this._sleep = sleep} } – Woken

Interesting. But what you call a weak association is not called an association in UML but a “usage dependency”. – Topographer

Answer 11

Composition (If you remove "whole", “part” is also removed automatically– “Ownership”)

• Create objects of your existing class inside the new class. This is called composition because the new class is composed of objects of existing classes.

• Typically use normal member variables.

• Can use pointer values if the composition class automatically handles allocation/deallocation responsible for creation/destruction of subclasses.

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

Output

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

Aggregation (If you remove "whole", “Part” can exist – “ No Ownership”)

• An aggregation is a specific type of composition where no ownership between the complex object and the subobjects is implied. When an aggregate is destroyed, the subobjects are not destroyed.

• Typically use pointer variables/reference variable that point to an object that lives outside the scope of the aggregate class

• Can use reference values that point to an object that lives outside the scope of the aggregate class

• Not responsible for creating/destroying subclasses

Aggregation Code in 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);
}

Output

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

Deandra

Whoever has down voted this answer. Can you please explain reason for down voting it ? – Deandra

What really confuses me is that, in many cases, it is not the owner hold the thing, but the thing it owns "hold" the owner. For example, the car does not have a Engine * type pointer, but the Engine class has a Car type member to store the car that owns it. I don't quite understand it especially the uml relationship of the classes in this case. – Tophole

Answer 12

Problem with these answers is they are half the story: they explain that aggregation and composition are forms of association, but they don't say if it is possible for an association to be neither of those.

I gather based on some brief readings of many posts on SO and some UML docs that there are 4 main concrete forms of class association:

1. composition: A is-composed-of-a B; B doesn't exist without A, like a room in a home
2. aggregation: A has-a B; B can exist without A, like a student in a classroom
3. dependency: A uses-a B; no lifecycle dependency between A and B, like a method call parameter, return value, or a temporary created during a method call
4. generalization: A is-a B

When a relationship between two entities isn't one of these, it can just be called "an association" in the generic sense of the term, and further described other ways (note, stereotype, etc).

My guess is that the "generic association" is intended to be used primarily in two circumstances:

• when the specifics of a relationship are still being worked out; such relationship in a diagram should be converted as soon as possible to what it actually is/will be (one of the other 4).
• when a relationship doesn't match any of those 4 predetermined by UML; the "generic" association still gives you a way of representing a relationship that is "not one of the other ones", so that you aren't stuck using an incorrect relationship with a note "this is not actually aggregation, it's just that UML doesn't have any other symbol we could use"

Dying

How exactly would you implement a generic association if all the other options are ruled out? If A is not composed of B (B's value is in A), A is not an aggregation of B (B's reference is not in A), B is not inherited/realized from A nor is B used as a return, parameter or within function usage of A, you're pretty much left with no relation whatsoever. – Vinita

@DeanP It can just be generic for the time being, and later will be converted to one of the 4 (then it becomes implementable); OR it can be a relationship that doesn't fit the 4 like say you want an association that means "looks like", without a generic association you will be forced to use one of the 4, thus misleading the reader, whereas if you use generic you will likely annotate it or put a note explaining what it is, and most people only read notes if they don't understand the symbol ;) – Dying

Answer 13

In a very simple sentence:
Aggregation and Composition are subsets of association.

• A uses B -> this is an aggregation

• A needs B -> is composition.

Read more here.

Polygamous

Answer 14

    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.

Joannjoanna

Answer 15

Association is a relationship between two separate classes and the association can be of any type say one to one, one to may etc. It joins two entirely separate entities.

Aggregation is a special form of association which is a unidirectional one way relationship between classes (or entities), for e.g. Wallet and Money classes. Wallet has Money but money doesn’t need to have Wallet necessarily so its a one directional relationship. In this relationship both the entries can survive if other one ends. In our example if Wallet class is not present, it does not mean that the Money class cannot exist.

Composition is a restricted form of Aggregation in which two entities (or you can say classes) are highly dependent on each other. For e.g. Human and Heart. A human needs heart to live and a heart needs a Human body to survive. In other words when the classes (entities) are dependent on each other and their life span are same (if one dies then another one too) then its a composition. Heart class has no sense if Human class is not present.

Unsuccessful

Answer 16

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

Composition: is a "part-of" relationship.

for example “engine is part of the car”, “heart is part of the body”.

Association: is a “has-a” type relationship

For example, suppose we have two classes then these two classes are said to be “has-a” relationships if both of these entities share each other’s object for some work and at the same time they can exist without each other's dependency or both have their own lifetime.

The above example showing an association relationship because of both Employee and Manager class using the object of each other and both their own independent life cycle.

Aggregation: is based is on "has-a" relationship and it's is \\a special form of association

for example, “Student” and “address”. Each student must have an address so the relationship between Student class and Address class will be “Has-A” type relationship but vice versa is not true.

Divergency

Association can be one way in a UML diagram though so I cannot understand the difference between your example of association and aggregation, they both look to be association. An address isn't part of a Student and I thought aggregation also defined a whole-part relationship, at least according to Bennetts book. – Veal

Answer 17

I think this link will do your homework: http://ootips.org/uml-hasa.html

To understand the terms I remember an example in my early programming days:

If you have a 'chess board' object that contains 'box' objects that is composition because if the 'chess board' is deleted there is no reason for the boxes to exist anymore.

If you have a 'square' object that have a 'color' object and the square gets deleted the 'color' object may still exist, that is aggregation

Both of them are associations, the main difference is conceptual

Acanthopterygian

Answer 18

Composition: This is where once you destroy an object (School), another object (Classrooms) which is bound to it would get destroyed too. Both of them can't exist independently.

Aggregation: This is sorta the exact opposite of the above (Composition) association where once you kill an object (Company), the other object (Employees) which is bound to it can exist on its own.

Association.
Composition and Aggregation are the two forms of association.

Armalla

Strictly speaking, employees of a company cannot exist without a company. It is true, you don't kill the people, but they are no longer employees of that company. So I think a better analogy would be with a Branch and Employees, where even if the branch closes, they might continue to be employees of the company. – Alvis

yup, absolutely. Do agree... +1 Thanks @AlexPopov for pointing it out. :) – Armalla

Answer 19

From: Remo H. Jansen book “Beginning React: Learning TypeScript 2.x - Second Edition” :

We call association those relationships whose objects have an independent life cycle where there is no ownership of the objects. Let's take a look at an example of a teacher and a student. Multiple students can be associated with a single teacher, and a single student can be associated with multiple teachers, but both have independent life cycles (both can create and delete independently). So, when a teacher leaves the school, we don't need to delete any students, and when a student leaves the school, we don't need to delete any teachers.

We call aggregation those relationships whose objects have an independent life cycle, but there is ownership, and child objects cannot belong to another parent object. Let's take an example of a cell phone and a cell phone battery. A single battery can belong to a phone, but if the phone stops working, and we delete it from our database, the phone battery will not be deleted because it may still be functional. So, in aggregation, while there is ownership, objects have their life cycle

We use the term composition to refer to relationships whose objects don't have an independent life cycle, and if the parent object is deleted, all child objects will also be deleted. Let's take an example of the relationship between questions and answers. Single questions can have multiple answers, and answers cannot belong to multiple questions. If we delete questions, answers will automatically be deleted.

Exuviae

Answer 20

I'd like to illustrate how the three terms are implemented in Rails. ActiveRecord calls any type of relationship between two models an association. One would not find very often the terms composition and aggregation, when reading documentation or articles, related to ActiveRecord. An association is created by adding one of the association class macros to the body of the class. Some of these macros are belongs_to, has_one, has_many etc..

If we want to set up a composition or aggregation, we need to add belongs_to to the owned model (also called child) and has_one or has_many to the owning model (also called parent). Wether we set up composition or aggregation depends on the options we pass to the belongs_to call in the child model. Prior to Rails 5, setting up belongs_to without any options created an aggregation, the child could exist without a parent. If we wanted a composition, we needed to explicitly declare this by adding the option required: true:

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

In Rails 5 this was changed. Now, declaring a belongs_to association creates a composition by default, the child cannot exist without a parent. So the above example can be re-written as:

class Room < ApplicationRecord
  belongs_to :house
end

If we want to allow the child object to exist without a parent, we need to declare this explicitly via the option optional

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

Alvis

Answer 21

in OOP, classes are related to each other. It means their instances call methods from each other. So, if instances of a class call methods from another class, they are related and generally we model this relationship with ASSOCIATION. For example in the following code snippet, the Customer class is associated with the Order class. she/he cancels the orders.

class Customer {
        private Order[] orders;
        public boolean removeCart() {
                for (int i = 0 ; i < orders.length ; i++) {
                        orders[i].cancel();
                }
        }
}

AGGREGATION means a class has some instances of another class. it's nothing more than association and Martin Fowler suggests not using it. Because when a class is associated with another class it has a reference to that class to invoke the methods on it.

But COMPOSITION is a meaningful subset of association. It means a class is composed of some other classes. For example we have a Student class composed of some other classes like ReportCard. We know that the report card is strongly dependent to the student and if we remove the student from the system, their report card should be removed too.

Budding