Aggregation

A "has-a" relationship where a container holds references to objects that can exist independently of it — a whole-part relationship without ownership.

The Problem

Some objects logically belong to a group, but shouldn't be destroyed when the group is destroyed — deleting a Playlist shouldn't delete the Songs it contains.

How It Works

›The "part" can exist independently of the "whole" and can be shared across multiple wholes
›Represented as a collection of references, not owned instances
›Destroying the container does not destroy its parts
›A weaker form of ownership than composition

When to Use

✓A Playlist containing Songs that also exist outside the playlist

✓A Department containing Employees who could move to another department

✓A Team referencing Players who exist independently of the team

Real-World Examples

🍎

iOS

An array of shared model objects referenced by multiple view controllers

🤖

Android

A Playlist entity referencing Song IDs stored in a Room database

🌐

Web

A shopping cart holding references to Product objects from a catalog

Code Examples

Swift

class Song {
    let title: String
    init(title: String) { self.title = title }
}

class Playlist {
    let name: String
    private(set) var songs: [Song] = []

    init(name: String) { self.name = name }

    func add(_ song: Song) {
        songs.append(song)
    }
}

let bohemianRhapsody = Song(title: "Bohemian Rhapsody")
let playlist = Playlist(name: "Road Trip")
playlist.add(bohemianRhapsody)
// bohemianRhapsody still exists even if `playlist` is deallocated