Free AI web copilot to create summaries, insights and extended knowledge, download it at here

1763

Abstract

container. If the container is destroyed, the child is also destroyed.Take for example a <code>Page</code> and a <code>Book</code>. The <code>Page</code> cannot exist without the <code>Book</code>, because the book is composed of <code>Pages</code>. If the <code>Book</code> is destroyed, the <code>Page</code> is also destroyed.In code, this usually refers to the child instance being created inside the container class:<div id="5a35"><pre>class Book: def init(self): page1 = Page('This is content for page 1') page2 = Page('This is content for page 2') self.pages = [page1, page2]

class Page: def init(self, content): self.content = content</pre></div><div id="7464"><pre>book = Book() # If I destroy this Book instance, # the Page instances are also destroyed</pre></div><h2 id="86e6">Aggregation</h2>With an aggregation, the child can

Options

exist independently of the parent.So thinking of a <code>Car</code> and an <code>Engine</code>, the <code>Engine</code> doesn’t need to be destroyed when the <code>Car</code> is destroyed.<div id="a1d8"><pre>class Car: def init(self, engine): self.engine = engine

class Engine: def init(self): pass</pre></div><div id="a80e"><pre>engine = Engine() car = Car(engine) # If I destroy this Car instance, # the Engine instance still exists</pre></div><h1 id="3b9b">How are these represented a UML diagram?</h1>In a UML diagram, both Aggregation and Composition are represented with a diamond arrow between the classes. The diamond end goes on the side of the container.<ul><li>Aggregation uses an open diamond</li><li>Composition uses a closed diamond</li></ul>Here’s an example:<figure id="2062"><img src="https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*D7TuM5p9Dl-tEELM3HnySQ.png"><figcaption></figcaption></figure>Hope this helped!</article></body>

Aggregation vs. Composition in Object Oriented Programming

In Object Oriented Programming, there are many different types of relationships which can exist between two or more classes. The most common two types are:

Inheritance — an “is a” relationship
Association — a “has a” relationship

This blog is going to do a deep dive into the two types of Association relationships — Aggregation and Composition.

What is an Association relationship?

An association relationship between two classes is a “has a” relationship. For example:

A Car has an Engine and a Wheel
A Person has a Leg and an Arm
A Book has Pages

This usually represents when there are two classes, ClassA and ClassB, and either:

ClassA contains ClassB as an attribute, or
Instances of ClassB are constructed inside ClassA

What’s the difference between Aggregation and Composition?

There are two sub-types of Association relationships — Aggregation and Composition. What’s the difference between these two?

Composition

Composition implies that the contained class cannot exist independently of the container. If the container is destroyed, the child is also destroyed.

Take for example a Page and a Book. The Page cannot exist without the Book, because the book is composed of Pages. If the Book is destroyed, the Page is also destroyed.

In code, this usually refers to the child instance being created inside the container class:

class Book:
    def __init__(self):
       page1 = Page('This is content for page 1')
       page2 = Page('This is content for page 2')
       self.pages = [page1, page2]

class Page:
    def __init__(self, content):
        self.content = content

book = Book() # If I destroy this Book instance,
              # the Page instances are also destroyed

Aggregation

With an aggregation, the child can exist independently of the parent.

So thinking of a Car and an Engine, the Engine doesn’t need to be destroyed when the Car is destroyed.

class Car:
    def __init__(self, engine):
        self.engine = engine

class Engine:
    def __init__(self):
        pass

engine = Engine()
car = Car(engine) # If I destroy this Car instance,
                  # the Engine instance still exists

How are these represented a UML diagram?

In a UML diagram, both Aggregation and Composition are represented with a diamond arrow between the classes. The diamond end goes on the side of the container.

Aggregation uses an open diamond
Composition uses a closed diamond

Here’s an example:

Hope this helped!