Class Relationships: Association, Aggregation and Composition

 WEAKEST                                                        STRONGEST
    |                                                                |
    v                                                                v
 Dependency  ->  Association  ->  Aggregation  ->  Composition  ->  Inheritance
  "uses-a"        "knows-a"        "has-a"          "owns-a"         "is-a"

  Method param    Field holding    Field holding    Field holding    extends /
  or local var    another object   parts that can   parts that die   implements
  only            long term        live alone       with the whole

                  \_____________ all three are HAS-A ______________/

+-------------------------------------------------------+
|                     ASSOCIATION                        |
|   (any long term link between two classes)             |
|                                                        |
|    +-----------------------------------------+         |
|    |              AGGREGATION                |         |
|    |   (whole-part, parts can live alone)    |         |
|    |                                         |         |
|    |     +-----------------------------+     |         |
|    |     |        COMPOSITION          |     |         |
|    |     |  (whole-part, parts die     |     |         |
|    |     |   with the whole)           |     |         |
|    |     +-----------------------------+     |         |
|    +-----------------------------------------+         |
+-------------------------------------------------------+

              +----------------------------+
              |   How is A related to B?   |
              +----------------------------+
                 |          |          |
        "A is a B"     "A has a B"   "A uses a B"
             |              |              |
             v              v              v
        INHERITANCE     ASSOCIATION     DEPENDENCY
        extends /       AGGREGATION     method
        implements      COMPOSITION     parameter

class Animal { }
class Dog extends Animal { }          // Dog IS-A Animal

interface PaymentMethod { void pay(double amount); }
class CreditCard implements PaymentMethod { }   // CreditCard IS-A PaymentMethod

class Car {
    private final Engine engine;    // Car HAS-A Engine
}

                        HAS-A
        (A holds B as a field and uses it)
                          |
      +-------------------+-------------------+
      |                   |                   |
 ASSOCIATION         AGGREGATION         COMPOSITION
 plain link          weak ownership      strong ownership
 no whole-part       part can live       part dies with
                     without the whole   the whole
      |                   |                   |
 Teacher has a       Library has a       Car has an
 Student list        Book list           Engine

class ReportService {
    void print(Report report) {       // ReportService USES-A Report
        System.out.println(report.render());
    }
}

// IS-A: true for a kind of engine (but Car extends Engine would be wrong)
class ElectricEngine extends Engine { }        // an electric engine IS an engine

// HAS-A: Car keeps an Engine as a field
class Car {
    private final Engine engine;

    Car(String model) {
        this.engine = new Engine(model);       // created inside, so composition
    }

    void start() {
        engine.ignite();
    }
}

// USES-A: the mechanic does not own an engine, one is handed to him per job
class Mechanic {
    void service(Engine engine) {              // parameter only
        engine.checkOilLevel();
    }
}

Association     Teacher ------------ Student          (plain line)

Aggregation     Department <>------- Employee         (hollow diamond on Department)

Composition     House <#>----------- Room             (filled diamond on House)

Dependency      Printer - - - - - -> Document         (dashed arrow)

Inheritance     Animal <|----------- Dog              (hollow triangle on Animal)

   Department                        Employee
   +----------+  1            0..*   +----------+
   |          |<>--------------------|          |
   +----------+                      +----------+

Read it as: one Department has zero or more Employees.

class Passport {
    private final String number;

    Passport(String number) {
        this.number = number;
    }

    String getNumber() {
        return number;
    }
}

class Person {
    private final String name;
    private Passport passport;   // one person, one passport

    Person(String name) {
        this.name = name;
    }

    void assignPassport(Passport passport) {
        this.passport = passport;
    }
}

class Teacher {
    private final String name;
    private final List<Student> students = new ArrayList<>();

    Teacher(String name) {
        this.name = name;
    }

    void addStudent(Student student) {
        students.add(student);
    }
}

class Student {
    private final String name;

    Student(String name) {
        this.name = name;
    }
}

class Student {
    private final String name;
    private final List<Course> courses = new ArrayList<>();

    Student(String name) {
        this.name = name;
    }

    void enroll(Course course) {
        courses.add(course);
        course.addStudent(this);   // keep both sides in sync
    }
}

class Course {
    private final String title;
    private final List<Student> students = new ArrayList<>();

    Course(String title) {
        this.title = title;
    }

    void addStudent(Student student) {
        students.add(student);
    }
}

Unidirectional:  Order  ------->  Customer
                 Order knows its Customer.
                 Customer does not know its Orders.

Bidirectional:   Student <------> Course
                 Both sides hold a reference to the other.

class Employee {
    private final String name;

    Employee(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }
}

class Department {
    private final String name;
    private final List<Employee> employees;

    // Employees are created outside and passed in.
    // The department only borrows them.
    Department(String name, List<Employee> employees) {
        this.name = name;
        this.employees = employees;
    }

    void addEmployee(Employee employee) {
        employees.add(employee);
    }
}

Employee rizon = new Employee("Rizon");
Employee aisha = new Employee("Aisha");

Department backend = new Department("Backend", new ArrayList<>(List.of(rizon, aisha)));

backend = null;   // department is gone

System.out.println(rizon.getName());   // still prints "Rizon", the object is alive

class Room {
    private final String name;
    private final double areaSqFt;

    Room(String name, double areaSqFt) {
        this.name = name;
        this.areaSqFt = areaSqFt;
    }

    String getName() {
        return name;
    }
}

class House {
    private final String address;
    private final List<Room> rooms = new ArrayList<>();

    House(String address) {
        this.address = address;
        // The house creates its own rooms. Nobody outside can hand them in.
        rooms.add(new Room("Living Room", 320));
        rooms.add(new Room("Bedroom", 240));
    }

    // Return copies of the data, not the Room objects themselves.
    List<String> getRoomNames() {
        return rooms.stream().map(Room::getName).toList();
    }
}

class ReportService {
    // Report is used only here, not stored as a field.
    void print(Report report) {
        System.out.println(report.render());
    }
}

// AGGREGATION: parts come from outside, so they exist before and after
class Playlist {
    private final List<Song> songs;

    Playlist(List<Song> songs) {   // handed in
        this.songs = songs;
    }
}

Song song = new Song("Kesariya");
Playlist p1 = new Playlist(new ArrayList<>(List.of(song)));
Playlist p2 = new Playlist(new ArrayList<>(List.of(song)));   // same song in two playlists, fine


// COMPOSITION: parts are born inside, so they die inside
class Car {
    private final Engine engine;

    Car(String model) {
        this.engine = new Engine(model);   // created here, owned here
    }
}

Car car = new Car("Swift");
// There is no way to take this engine and put it in another Car.

persons                          passports
+----+---------+                 +----+------------+-----------+
| id | name    |                 | id | number     | person_id |  <- UNIQUE
+----+---------+                 +----+------------+-----------+
| 1  | Rizon   |                 | 9  | X1234567   | 1         |
| 2  | Aisha   |                 | 10 | Y7654321   | 2         |
+----+---------+                 +----+------------+-----------+

CREATE TABLE passports (
  id         BIGINT PRIMARY KEY,
  number     VARCHAR(20) NOT NULL,
  person_id  BIGINT UNIQUE REFERENCES persons(id)
);

departments                      employees
+----+-----------+               +----+--------+---------------+
| id | name      |               | id | name   | department_id |  <- nullable FK
+----+-----------+               +----+--------+---------------+
| 1  | Backend   |               | 5  | Rizon  | 1             |
| 2  | Design    |               | 6  | Aisha  | 1             |
+----+-----------+               | 7  | Karan  | NULL          |  <- no department, still an employee
                                 +----+--------+---------------+

CREATE TABLE employees (
  id            BIGINT PRIMARY KEY,
  name          VARCHAR(100) NOT NULL,
  department_id BIGINT NULL REFERENCES departments(id) ON DELETE SET NULL
);

students                 student_course                courses
+----+--------+          +------------+-----------+    +----+----------+
| id | name   |          | student_id | course_id |    | id | title    |
+----+--------+          +------------+-----------+    +----+----------+
| 1  | Rizon  |          | 1          | 100       |    |100 | DSA      |
| 2  | Aisha  |          | 1          | 101       |    |101 | DBMS     |
+----+--------+          | 2          | 100       |    +----+----------+
                         +------------+-----------+
                          PK (student_id, course_id)

CREATE TABLE student_course (
  student_id BIGINT REFERENCES students(id),
  course_id  BIGINT REFERENCES courses(id),
  PRIMARY KEY (student_id, course_id)
);

orders                           order_items
+----+------------+              +----+----------+----------+-----+
| id | placed_on  |              | id | order_id | sku      | qty |  <- NOT NULL FK
+----+------------+              +----+----------+----------+-----+
| 70 | 2026-08-16 |              | 1  | 70       | SHOE-42  | 1   |
+----+------------+              | 2  | 70       | SOCK-M   | 3   |
                                 +----+----------+----------+-----+

Delete order 70  ->  both item rows are deleted automatically.

CREATE TABLE order_items (
  id       BIGINT PRIMARY KEY,
  order_id BIGINT NOT NULL REFERENCES orders(id) ON DELETE CASCADE,
  sku      VARCHAR(40) NOT NULL,
  qty      INT NOT NULL
);

import java.util.*;

// PART owned by Book. Package private, so code in other packages cannot build one.
// (Demo below is in the same package, but it never does.)
class Chapter {
    private final String title;
    private final int pages;

    Chapter(String title, int pages) {
        this.title = title;
        this.pages = pages;
    }

    String getTitle() {
        return title;
    }

    int getPages() {
        return pages;
    }
}

class Book {
    private final String title;
    private final List<Chapter> chapters = new ArrayList<>();

    Book(String title) {
        this.title = title;
    }

    // COMPOSITION: the Book creates the Chapter. The caller only sends data.
    void addChapter(String chapterTitle, int pages) {
        chapters.add(new Chapter(chapterTitle, pages));
    }

    // Never hand out the real Chapter objects or the real list.
    List<String> getTableOfContents() {
        List<String> toc = new ArrayList<>();
        for (Chapter chapter : chapters) {
            toc.add(chapter.getTitle() + " (" + chapter.getPages() + " pages)");
        }
        return toc;
    }

    String getTitle() {
        return title;
    }
}

class Library {
    private final String name;
    private final List<Book> books = new ArrayList<>();

    Library(String name) {
        this.name = name;
    }

    // AGGREGATION: the Book is created outside and only borrowed.
    void addBook(Book book) {
        books.add(book);
    }

    void removeBook(Book book) {
        books.remove(book);   // the Book object is still alive for the caller
    }
}

public class Demo {
    public static void main(String[] args) {
        Book book = new Book("Clean Code");
        book.addChapter("Meaningful Names", 22);
        book.addChapter("Functions", 30);

        Library cityLibrary = new Library("City Library");
        cityLibrary.addBook(book);

        cityLibrary.removeBook(book);

        // Book survives, because Library only aggregated it.
        System.out.println(book.getTitle());              // Clean Code
        System.out.println(book.getTableOfContents());    // chapters still there

        // Chapters cannot survive without the Book: there is no reference to them
        // anywhere outside, so when `book` goes away they go away too.
    }
}

import java.util.*;

class Customer {
    private final String id;
    private final String name;

    Customer(String id, String name) {
        this.id = id;
        this.name = name;
    }

    String getName() {
        return name;
    }
}

class Address {
    private final String line1;
    private final String city;
    private final String pincode;

    Address(String line1, String city, String pincode) {
        this.line1 = line1;
        this.city = city;
        this.pincode = pincode;
    }
}

class OrderItem {
    private final String sku;
    private final int quantity;
    private final double unitPrice;

    // package private on purpose: other packages cannot build one, and only Order does here
    OrderItem(String sku, int quantity, double unitPrice) {
        this.sku = sku;
        this.quantity = quantity;
        this.unitPrice = unitPrice;
    }

    double lineTotal() {
        return quantity * unitPrice;
    }
}

class Payment {
    private final String txnId;
    private final double amount;

    Payment(String txnId, double amount) {
        this.txnId = txnId;
        this.amount = amount;
    }
}

class Order {
    private final String orderId;
    private final Customer customer;          // association, passed in
    private final Address shippingAddress;    // aggregation, reused from customer's list
    private final List<OrderItem> items = new ArrayList<>();   // composition, built here
    private Payment payment;                  // composition, built here

    Order(String orderId, Customer customer, Address shippingAddress) {
        this.orderId = orderId;
        this.customer = customer;
        this.shippingAddress = shippingAddress;
    }

    // Composition: Order creates the item, caller never sees the constructor
    void addItem(String sku, int quantity, double unitPrice) {
        items.add(new OrderItem(sku, quantity, unitPrice));
    }

    void pay(String txnId) {
        this.payment = new Payment(txnId, total());
    }

    double total() {
        double sum = 0;
        for (OrderItem item : items) {
            sum += item.lineTotal();
        }
        return sum;
    }
}

customers            addresses                   orders
+----+-------+       +----+-------------+        +----+----------+-------------+
| id | name  |       | id | customer_id |        | id | customer | address_id  |
+----+-------+       +----+-------------+        +----+----------+-------------+
| 1  | Rizon |       | 8  | 1           |        | 70 | 1        | 8           |
+----+-------+       +----+-------------+        +----+----------+-------------+
                      nullable FK                  customer_id NOT NULL, no cascade

order_items                                 payments
+----+----------+---------+-----+           +----+----------+--------+
| id | order_id | sku     | qty |           | id | order_id | amount |
+----+----------+---------+-----+           +----+----------+--------+
| 1  | 70       | SHOE-42 | 1   |           | 3  | 70       | 4999   |
+----+----------+---------+-----+           +----+----------+--------+
 order_id NOT NULL, ON DELETE CASCADE        order_id NOT NULL, ON DELETE CASCADE

// Looks like composition, but is not
class House {
    private final List<Room> rooms = new ArrayList<>();

    House() {
        rooms.add(new Room("Bedroom"));
    }

    List<Room> getRooms() {
        return rooms;   // BAD: caller can keep this list and the Rooms forever
    }
}

List<Room> escaped = new House().getRooms();
// house is gone, rooms are still alive. Ownership is broken.

List<Room> getRooms() {
    return List.copyOf(rooms);   // caller cannot add or remove
}

Does class A only use B inside a method, without storing it?
    YES -> Dependency
    NO  |
        v
Is A a special kind of B?
    YES -> Inheritance (extends / implements)
    NO  |
        v
Is B a part of A? (would you say "A has a B" in a whole-part sense)
    NO  -> Association
    YES |
        v
If A is deleted, should B be deleted too?
    NO  -> Aggregation   (hollow diamond, o--, FK nullable, SET NULL)
    YES -> Composition   (filled diamond, *--, FK not null, CASCADE)

DEPENDENCY   uses-a      A ..> B     method parameter only        Printer, Document
ASSOCIATION  has-a       A --> B     field, both independent      Teacher, Student
AGGREGATION  has-a       A o-- B     field, part passed in        Library, Book
COMPOSITION  has-a       A *-- B     field, part created inside   Car, Engine
INHERITANCE  is-a        A <|-- B    extends / implements         Animal, Dog

HAS-A is the family name for the middle three. They are all "B is a field
inside A", they only differ in who owns the lifecycle:
    association -> nobody owns anybody
    aggregation -> A holds B, B survives A
    composition -> A owns B, B dies with A

Diamond goes on the WHOLE.  Empty diamond = borrowed.  Filled diamond = owned.

Java tell:   new Part() outside the whole  -> aggregation
             new Part() inside the whole   -> composition

SQL tell:    ON DELETE SET NULL            -> aggregation
             ON DELETE CASCADE             -> composition

Multiplicity: 1   exactly one
              0..1 optional
              *    zero or more
              1..* at least one