All Together

See all relationships working together in a real-world system.

By Vishnu Darshan Sanku · Updated September 25, 2026

Video Explanation

Class Relationships Explained

Watch on YouTube

Let’s build a complete Library Management System that demonstrates all four class relationships working together.

System Overview

We’ll design a library system with:

Library (main system)
Book (items in library)
Member (people who borrow books)
Librarian (staff managing library)
Loan (borrowing record)
Fine (penalty for late returns)

Complete Implementation

💡 Tip: Click dropdown to switch between languages

1
from abc import ABC, abstractmethod
2
from datetime import datetime, timedelta
3

4
# ========== INHERITANCE ==========
5
class Person(ABC):
6
    """Base class using Inheritance"""
7
    def __init__(self, name: str, email: str):
8
        self.name = name
9
        self.email = email
10

11
    @abstractmethod
12
    def get_role(self):
13
        pass
14

15
# Inheritance - Member IS-A Person
16
class Member(Person):
17
    def __init__(self, name: str, email: str, member_id: str):
18
        super().__init__(name, email)
19
        self.member_id = member_id
20
        self.loans = []  # COMPOSITION - loans belong to member
21

22
    def get_role(self):
23
        return "Member"
24

25
    def borrow_book(self, book, librarian):
26
        # DEPENDENCY - uses Book and Librarian temporarily
27
        loan = Loan(self, book, librarian)
28
        self.loans.append(loan)  # COMPOSITION
29
        return loan
30

31
# Inheritance - Librarian IS-A Person
32
class Librarian(Person):
33
    def __init__(self, name: str, email: str, employee_id: str):
34
        super().__init__(name, email)
35
        self.employee_id = employee_id
36

37
    def get_role(self):
38
        return "Librarian"
39

40
    def process_return(self, loan):
41
        # DEPENDENCY - uses Loan temporarily
42
        loan.return_book()
43
        if loan.is_overdue():
44
            fine = Fine(loan)  # COMPOSITION - fine created with loan
45
            loan.fine = fine
46

47
# ========== COMPOSITION ==========
48
class Book:
49
    """Book is part of Library - COMPOSITION"""
50
    def __init__(self, isbn: str, title: str, author: str):
51
        self.isbn = isbn
52
        self.title = title
53
        self.author = author
54
        self.available = True
55

56
# COMPOSITION - Loan belongs to Member
57
class Loan:
58
    def __init__(self, member, book, librarian):
59
        self.member = member      # ASSOCIATION - references member
60
        self.book = book          # ASSOCIATION - references book
61
        self.librarian = librarian  # ASSOCIATION - references librarian
62
        self.borrow_date = datetime.now()
63
        self.due_date = self.borrow_date + timedelta(days=14)
64
        self.return_date = None
65
        self.fine = None  # COMPOSITION - optional fine
66

67
    def return_book(self):
68
        self.return_date = datetime.now()
69
        self.book.available = True
70

71
    def is_overdue(self):
72
        if self.return_date:
73
            return self.return_date > self.due_date
74
        return datetime.now() > self.due_date
75

76
# COMPOSITION - Fine belongs to Loan
77
class Fine:
78
    def __init__(self, loan):
79
        self.loan = loan  # ASSOCIATION - references loan
80
        days_overdue = (datetime.now() - loan.due_date).days
81
        self.amount = days_overdue * 0.50  # $0.50 per day
82

83
# ========== COMPOSITION & AGGREGATION ==========
84
class Library:
85
    """Library contains Books (COMPOSITION) and has Members/Librarians (AGGREGATION)"""
86
    def __init__(self, name: str):
87
        self.name = name
88
        self.books = []      # COMPOSITION - books belong to library
89
        self.members = []    # AGGREGATION - members can exist independently
90
        self.librarians = [] # AGGREGATION - librarians can exist independently
91

92
    def add_book(self, book):
93
        self.books.append(book)  # COMPOSITION
94

95
    def register_member(self, member):
96
        self.members.append(member)  # AGGREGATION
97

98
    def hire_librarian(self, librarian):
99
        self.librarians.append(librarian)  # AGGREGATION
100

101
    def find_book(self, isbn: str):
102
        """DEPENDENCY - uses string parameter"""
103
        for book in self.books:
104
            if book.isbn == isbn:
105
                return book
106
        return None
107

108
# ========== USAGE ==========
109
# Create library
110
library = Library("City Library")
111

112
# Create books (COMPOSITION - belong to library)
113
book1 = Book("12345", "Python Guide", "Author A")
114
book2 = Book("67890", "Java Guide", "Author B")
115
library.add_book(book1)
116
library.add_book(book2)
117

118
# Create members (AGGREGATION - can exist independently)
119
member1 = Member("Alice", "[email protected]", "M001")
120
member2 = Member("Bob", "[email protected]", "M002")
121
library.register_member(member1)
122
library.register_member(member2)
123

124
# Create librarian (AGGREGATION)
125
librarian = Librarian("Carol", "[email protected]", "L001")
126
library.hire_librarian(librarian)
127

128
# Member borrows book (creates ASSOCIATION and COMPOSITION)
129
loan = member1.borrow_book(book1, librarian)
130
print(f"{member1.name} borrowed {book1.title}")
131

132
# Librarian processes return (uses DEPENDENCY)
133
librarian.process_return(loan)
134
print(f"Book returned. Fine: ${loan.fine.amount if loan.fine else 0:.2f}")

1
import java.time.LocalDateTime;
2
import java.time.temporal.ChronoUnit;
3
import java.util.ArrayList;
4
import java.util.List;
5

6
// ========== INHERITANCE ==========
7
abstract class Person {
8
    protected String name;
9
    protected String email;
10

11
    public Person(String name, String email) {
12
        this.name = name;
13
        this.email = email;
14
    }
15

16
    public abstract String getRole();
17
}
18

19
// Inheritance - Member IS-A Person
20
class Member extends Person {
21
    private String memberId;
22
    private List<Loan> loans;  // COMPOSITION - loans belong to member
23

24
    public Member(String name, String email, String memberId) {
25
        super(name, email);
26
        this.memberId = memberId;
27
        this.loans = new ArrayList<>();
28
    }
29

30
    @Override
31
    public String getRole() {
32
        return "Member";
33
    }
34

35
    // DEPENDENCY - uses Book and Librarian temporarily
36
    public Loan borrowBook(Book book, Librarian librarian) {
37
        Loan loan = new Loan(this, book, librarian);
38
        loans.add(loan);  // COMPOSITION
39
        return loan;
40
    }
41
}
42

43
// Inheritance - Librarian IS-A Person
44
class Librarian extends Person {
45
    private String employeeId;
46

47
    public Librarian(String name, String email, String employeeId) {
48
        super(name, email);
49
        this.employeeId = employeeId;
50
    }
51

52
    @Override
53
    public String getRole() {
54
        return "Librarian";
55
    }
56

57
    // DEPENDENCY - uses Loan temporarily
58
    public void processReturn(Loan loan) {
59
        loan.returnBook();
60
        if (loan.isOverdue()) {
61
            Fine fine = new Fine(loan);  // COMPOSITION - fine created with loan
62
            loan.setFine(fine);
63
        }
64
    }
65
}
66

67
// ========== COMPOSITION ==========
68
class Book {
69
    private String isbn;
70
    private String title;
71
    private String author;
72
    private boolean available;
73

74
    public Book(String isbn, String title, String author) {
75
        this.isbn = isbn;
76
        this.title = title;
77
        this.author = author;
78
        this.available = true;
79
    }
80

81
    public String getTitle() {
82
        return title;
83
    }
84

85
    public boolean isAvailable() {
86
        return available;
87
    }
88

89
    public void setAvailable(boolean available) {
90
        this.available = available;
91
    }
92
}
93

94
// COMPOSITION - Loan belongs to Member
95
class Loan {
96
    private Member member;      // ASSOCIATION - references member
97
    private Book book;          // ASSOCIATION - references book
98
    private Librarian librarian; // ASSOCIATION - references librarian
99
    private LocalDateTime borrowDate;
100
    private LocalDateTime dueDate;
101
    private LocalDateTime returnDate;
102
    private Fine fine;          // COMPOSITION - optional fine
103

104
    public Loan(Member member, Book book, Librarian librarian) {
105
        this.member = member;
106
        this.book = book;
107
        this.librarian = librarian;
108
        this.borrowDate = LocalDateTime.now();
109
        this.dueDate = borrowDate.plusDays(14);
110
    }
111

112
    public void returnBook() {
113
        this.returnDate = LocalDateTime.now();
114
        book.setAvailable(true);
115
    }
116

117
    public boolean isOverdue() {
118
        if (returnDate != null) {
119
            return returnDate.isAfter(dueDate);
120
        }
121
        return LocalDateTime.now().isAfter(dueDate);
122
    }
123

124
    public void setFine(Fine fine) {
125
        this.fine = fine;
126
    }
127
}
128

129
// COMPOSITION - Fine belongs to Loan
130
class Fine {
131
    private Loan loan;  // ASSOCIATION - references loan
132
    private double amount;
133

134
    public Fine(Loan loan) {
135
        this.loan = loan;
136
        long daysOverdue = ChronoUnit.DAYS.between(loan.dueDate, LocalDateTime.now());
137
        this.amount = daysOverdue * 0.50;  // $0.50 per day
138
    }
139

140
    public double getAmount() {
141
        return amount;
142
    }
143
}
144

145
// ========== COMPOSITION & AGGREGATION ==========
146
class Library {
147
    private String name;
148
    private List<Book> books;      // COMPOSITION - books belong to library
149
    private List<Member> members;  // AGGREGATION - members can exist independently
150
    private List<Librarian> librarians; // AGGREGATION - librarians can exist independently
151

152
    public Library(String name) {
153
        this.name = name;
154
        this.books = new ArrayList<>();
155
        this.members = new ArrayList<>();
156
        this.librarians = new ArrayList<>();
157
    }
158

159
    public void addBook(Book book) {
160
        books.add(book);  // COMPOSITION
161
    }
162

163
    public void registerMember(Member member) {
164
        members.add(member);  // AGGREGATION
165
    }
166

167
    public void hireLibrarian(Librarian librarian) {
168
        librarians.add(librarian);  // AGGREGATION
169
    }
170

171
    // DEPENDENCY - uses string parameter
172
    public Book findBook(String isbn) {
173
        for (Book book : books) {
174
            if (book.getIsbn().equals(isbn)) {
175
                return book;
176
            }
177
        }
178
        return null;
179
    }
180
}
181

182
// ========== USAGE ==========
183
public class Main {
184
    public static void main(String[] args) {
185
        // Create library
186
        Library library = new Library("City Library");
187

188
        // Create books (COMPOSITION - belong to library)
189
        Book book1 = new Book("12345", "Python Guide", "Author A");
190
        Book book2 = new Book("67890", "Java Guide", "Author B");
191
        library.addBook(book1);
192
        library.addBook(book2);
193

194
        // Create members (AGGREGATION - can exist independently)
195
        Member member1 = new Member("Alice", "[email protected]", "M001");
196
        Member member2 = new Member("Bob", "[email protected]", "M002");
197
        library.registerMember(member1);
198
        library.registerMember(member2);
199

200
        // Create librarian (AGGREGATION)
201
        Librarian librarian = new Librarian("Carol", "[email protected]", "L001");
202
        library.hireLibrarian(librarian);
203

204
        // Member borrows book (creates ASSOCIATION and COMPOSITION)
205
        Loan loan = member1.borrowBook(book1, librarian);
206
        System.out.println(member1.name + " borrowed " + book1.getTitle());
207

208
        // Librarian processes return (uses DEPENDENCY)
209
        librarian.processReturn(loan);
210
        System.out.println("Book returned. Fine: $" +
211
                          (loan.fine != null ? loan.fine.getAmount() : 0));
212
    }
213
}

1
// ========== INHERITANCE ==========
2
abstract class Person {
3
    protected name: string;
4
    protected email: string;
5

6
    constructor(name: string, email: string) {
7
        this.name = name;
8
        this.email = email;
9
    }
10

11
    abstract getRole(): string;
12
}
13

14
// Inheritance - Member IS-A Person
15
class Member extends Person {
16
    private memberId: string;
17
    private loans: Loan[];  // COMPOSITION - loans belong to member
18

19
    constructor(name: string, email: string, memberId: string) {
20
        super(name, email);
21
        this.memberId = memberId;
22
        this.loans = [];
23
    }
24

25
    getRole(): string {
26
        return "Member";
27
    }
28

29
    // DEPENDENCY - uses Book and Librarian temporarily
30
    borrowBook(book: Book, librarian: Librarian): Loan {
31
        const loan = new Loan(this, book, librarian);
32
        this.loans.push(loan);  // COMPOSITION
33
        return loan;
34
    }
35
}
36

37
// Inheritance - Librarian IS-A Person
38
class Librarian extends Person {
39
    private employeeId: string;
40

41
    constructor(name: string, email: string, employeeId: string) {
42
        super(name, email);
43
        this.employeeId = employeeId;
44
    }
45

46
    getRole(): string {
47
        return "Librarian";
48
    }
49

50
    // DEPENDENCY - uses Loan temporarily
51
    processReturn(loan: Loan): void {
52
        loan.returnBook();
53
        if (loan.isOverdue()) {
54
            const fine = new Fine(loan);  // COMPOSITION - fine created with loan
55
            loan.setFine(fine);
56
        }
57
    }
58
}
59

60
// ========== COMPOSITION ==========
61
class Book {
62
    private isbn: string;
63
    private title: string;
64
    private author: string;
65
    public available: boolean;
66

67
    constructor(isbn: string, title: string, author: string) {
68
        this.isbn = isbn;
69
        this.title = title;
70
        this.author = author;
71
        this.available = true;
72
    }
73

74
    getTitle(): string {
75
        return this.title;
76
    }
77
}
78

79
// COMPOSITION - Loan belongs to Member
80
class Loan {
81
    private member: Member;      // ASSOCIATION - references member
82
    private book: Book;          // ASSOCIATION - references book
83
    private librarian: Librarian; // ASSOCIATION - references librarian
84
    private borrowDate: Date;
85
    private dueDate: Date;
86
    private returnDate: Date | null;
87
    private fine: Fine | null;   // COMPOSITION - optional fine
88

89
    constructor(member: Member, book: Book, librarian: Librarian) {
90
        this.member = member;
91
        this.book = book;
92
        this.librarian = librarian;
93
        this.borrowDate = new Date();
94
        this.dueDate = new Date(this.borrowDate.getTime() + 14 * 24 * 60 * 60 * 1000);
95
        this.returnDate = null;
96
        this.fine = null;
97
    }
98

99
    returnBook(): void {
100
        this.returnDate = new Date();
101
        this.book.available = true;
102
    }
103

104
    isOverdue(): boolean {
105
        if (this.returnDate) {
106
            return this.returnDate > this.dueDate;
107
        }
108
        return new Date() > this.dueDate;
109
    }
110

111
    setFine(fine: Fine): void {
112
        this.fine = fine;
113
    }
114

115
    getFine(): Fine | null {
116
        return this.fine;
117
    }
118
}
119

120
// COMPOSITION - Fine belongs to Loan
121
class Fine {
122
    private loan: Loan;  // ASSOCIATION - references loan
123
    public amount: number;
124

125
    constructor(loan: Loan) {
126
        this.loan = loan;
127
        const daysOverdue = Math.floor(
128
            (new Date().getTime() - loan['dueDate'].getTime()) / (24 * 60 * 60 * 1000)
129
        );
130
        this.amount = daysOverdue * 0.50;  // $0.50 per day
131
    }
132
}
133

134
// ========== COMPOSITION & AGGREGATION ==========
135
class Library {
136
    private name: string;
137
    private books: Book[];      // COMPOSITION - books belong to library
138
    private members: Member[];  // AGGREGATION - members can exist independently
139
    private librarians: Librarian[]; // AGGREGATION - librarians can exist independently
140

141
    constructor(name: string) {
142
        this.name = name;
143
        this.books = [];
144
        this.members = [];
145
        this.librarians = [];
146
    }
147

148
    addBook(book: Book): void {
149
        this.books.push(book);  // COMPOSITION
150
    }
151

152
    registerMember(member: Member): void {
153
        this.members.push(member);  // AGGREGATION
154
    }
155

156
    hireLibrarian(librarian: Librarian): void {
157
        this.librarians.push(librarian);  // AGGREGATION
158
    }
159

160
    // DEPENDENCY - uses string parameter
161
    findBook(isbn: string): Book | null {
162
        return this.books.find(book => book['isbn'] === isbn) || null;
163
    }
164
}
165

166
// ========== USAGE ==========
167
// Create library
168
const library = new Library("City Library");
169

170
// Create books (COMPOSITION - belong to library)
171
const book1 = new Book("12345", "Python Guide", "Author A");
172
const book2 = new Book("67890", "Java Guide", "Author B");
173
library.addBook(book1);
174
library.addBook(book2);
175

176
// Create members (AGGREGATION - can exist independently)
177
const member1 = new Member("Alice", "[email protected]", "M001");
178
const member2 = new Member("Bob", "[email protected]", "M002");
179
library.registerMember(member1);
180
library.registerMember(member2);
181

182
// Create librarian (AGGREGATION)
183
const librarian = new Librarian("Carol", "[email protected]", "L001");
184
library.hireLibrarian(librarian);
185

186
// Member borrows book (creates ASSOCIATION and COMPOSITION)
187
const loan = member1.borrowBook(book1, librarian);
188
console.log(`${member1['name']} borrowed ${book1.getTitle()}`);
189

190
// Librarian processes return (uses DEPENDENCY)
191
librarian.processReturn(loan);
192
const fine = loan.getFine();
193
console.log(`Book returned. Fine: $${fine ? fine.amount.toFixed(2) : '0.00'}`);

1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <memory>
5
#include <chrono>
6
#include <ctime>
7
#include <iomanip>
8

9
using namespace std;
10

11
// Forward declarations
12
class Loan;
13
class Fine;
14
class Book;
15
class Librarian;
16

17
// ========== INHERITANCE ==========
18
class Person {
19
protected:
20
    string name;
21
    string email;
22

23
public:
24
    Person(const string& name, const string& email)
25
        : name(name), email(email) {}
26

27
    virtual ~Person() = default;
28
    virtual string getRole() const = 0;
29

30
    string getName() const { return name; }
31
};
32

33
// Inheritance - Member IS-A Person
34
class Member : public Person {
35
private:
36
    string memberId;
37
    vector<shared_ptr<Loan>> loans;  // COMPOSITION - loans belong to member
38

39
public:
40
    Member(const string& name, const string& email, const string& memberId)
41
        : Person(name, email), memberId(memberId) {}
42

43
    string getRole() const override {
44
        return "Member";
45
    }
46

47
    // DEPENDENCY - uses Book and Librarian temporarily
48
    shared_ptr<Loan> borrowBook(shared_ptr<Book> book, shared_ptr<Librarian> librarian);
49

50
    void addLoan(shared_ptr<Loan> loan) {
51
        loans.push_back(loan);  // COMPOSITION
52
    }
53
};
54

55
// Inheritance - Librarian IS-A Person
56
class Librarian : public Person {
57
private:
58
    string employeeId;
59

60
public:
61
    Librarian(const string& name, const string& email, const string& employeeId)
62
        : Person(name, email), employeeId(employeeId) {}
63

64
    string getRole() const override {
65
        return "Librarian";
66
    }
67

68
    // DEPENDENCY - uses Loan temporarily
69
    void processReturn(shared_ptr<Loan> loan);
70
};
71

72
// ========== COMPOSITION ==========
73
class Book {
74
private:
75
    string isbn;
76
    string title;
77
    string author;
78

79
public:
80
    bool available;
81

82
    Book(const string& isbn, const string& title, const string& author)
83
        : isbn(isbn), title(title), author(author), available(true) {}
84

85
    string getTitle() const { return title; }
86
    string getIsbn() const { return isbn; }
87
};
88

89
// COMPOSITION - Loan belongs to Member
90
class Loan {
91
private:
92
    shared_ptr<Member> member;      // ASSOCIATION - references member
93
    shared_ptr<Book> book;          // ASSOCIATION - references book
94
    shared_ptr<Librarian> librarian; // ASSOCIATION - references librarian
95
    time_t borrowDate;
96
    time_t dueDate;
97
    time_t returnDate;
98
    shared_ptr<Fine> fine;          // COMPOSITION - optional fine
99
    bool returned;
100

101
public:
102
    Loan(shared_ptr<Member> member, shared_ptr<Book> book, shared_ptr<Librarian> librarian)
103
        : member(member), book(book), librarian(librarian), returned(false) {
104
        borrowDate = time(nullptr);
105
        dueDate = borrowDate + (14 * 24 * 60 * 60);  // 14 days
106
        returnDate = 0;
107
    }
108

109
    void returnBook() {
110
        returnDate = time(nullptr);
111
        returned = true;
112
        book->available = true;
113
    }
114

115
    bool isOverdue() const {
116
        if (returned) {
117
            return returnDate > dueDate;
118
        }
119
        return time(nullptr) > dueDate;
120
    }
121

122
    void setFine(shared_ptr<Fine> f) {
123
        fine = f;
124
    }
125

126
    shared_ptr<Fine> getFine() const {
127
        return fine;
128
    }
129

130
    time_t getDueDate() const { return dueDate; }
131
};
132

133
// COMPOSITION - Fine belongs to Loan
134
class Fine {
135
private:
136
    shared_ptr<Loan> loan;  // ASSOCIATION - references loan
137

138
public:
139
    double amount;
140

141
    Fine(shared_ptr<Loan> loan) : loan(loan) {
142
        time_t now = time(nullptr);
143
        int daysOverdue = (now - loan->getDueDate()) / (24 * 60 * 60);
144
        amount = daysOverdue * 0.50;  // $0.50 per day
145
    }
146
};
147

148
// Member method implementation (after Loan and Fine are defined)
149
shared_ptr<Loan> Member::borrowBook(shared_ptr<Book> book, shared_ptr<Librarian> librarian) {
150
    auto loan = make_shared<Loan>(shared_from_this(), book, librarian);
151
    addLoan(loan);
152
    return loan;
153
}
154

155
// Librarian method implementation
156
void Librarian::processReturn(shared_ptr<Loan> loan) {
157
    loan->returnBook();
158
    if (loan->isOverdue()) {
159
        auto fine = make_shared<Fine>(loan);  // COMPOSITION - fine created with loan
160
        loan->setFine(fine);
161
    }
162
}
163

164
// ========== COMPOSITION & AGGREGATION ==========
165
class Library {
166
private:
167
    string name;
168
    vector<shared_ptr<Book>> books;      // COMPOSITION - books belong to library
169
    vector<shared_ptr<Member>> members;  // AGGREGATION - members can exist independently
170
    vector<shared_ptr<Librarian>> librarians; // AGGREGATION - librarians can exist independently
171

172
public:
173
    Library(const string& name) : name(name) {}
174

175
    void addBook(shared_ptr<Book> book) {
176
        books.push_back(book);  // COMPOSITION
177
    }
178

179
    void registerMember(shared_ptr<Member> member) {
180
        members.push_back(member);  // AGGREGATION
181
    }
182

183
    void hireLibrarian(shared_ptr<Librarian> librarian) {
184
        librarians.push_back(librarian);  // AGGREGATION
185
    }
186

187
    // DEPENDENCY - uses string parameter
188
    shared_ptr<Book> findBook(const string& isbn) {
189
        for (auto& book : books) {
190
            if (book->getIsbn() == isbn) {
191
                return book;
192
            }
193
        }
194
        return nullptr;
195
    }
196
};
197

198
// ========== USAGE ==========
199
int main() {
200
    // Create library
201
    auto library = make_shared<Library>("City Library");
202

203
    // Create books (COMPOSITION - belong to library)
204
    auto book1 = make_shared<Book>("12345", "Python Guide", "Author A");
205
    auto book2 = make_shared<Book>("67890", "Java Guide", "Author B");
206
    library->addBook(book1);
207
    library->addBook(book2);
208

209
    // Create members (AGGREGATION - can exist independently)
210
    auto member1 = make_shared<Member>("Alice", "[email protected]", "M001");
211
    auto member2 = make_shared<Member>("Bob", "[email protected]", "M002");
212
    library->registerMember(member1);
213
    library->registerMember(member2);
214

215
    // Create librarian (AGGREGATION)
216
    auto librarian = make_shared<Librarian>("Carol", "[email protected]", "L001");
217
    library->hireLibrarian(librarian);
218

219
    // Member borrows book (creates ASSOCIATION and COMPOSITION)
220
    auto loan = member1->borrowBook(book1, librarian);
221
    cout << member1->getName() << " borrowed " << book1->getTitle() << endl;
222

223
    // Librarian processes return (uses DEPENDENCY)
224
    librarian->processReturn(loan);
225
    auto fine = loan->getFine();
226
    cout << fixed << setprecision(2);
227
    cout << "Book returned. Fine: $" << (fine ? fine->amount : 0.0) << endl;
228

229
    return 0;
230
}

1
using System;
2
using System.Collections.Generic;
3
using System.Linq;
4

5
// ========== INHERITANCE ==========
6
public abstract class Person
7
{
8
    protected string name;
9
    protected string email;
10

11
    public Person(string name, string email)
12
    {
13
        this.name = name;
14
        this.email = email;
15
    }
16

17
    public abstract string GetRole();
18

19
    public string Name => name;
20
}
21

22
// Inheritance - Member IS-A Person
23
public class Member : Person
24
{
25
    private string memberId;
26
    private List<Loan> loans;  // COMPOSITION - loans belong to member
27

28
    public Member(string name, string email, string memberId)
29
        : base(name, email)
30
    {
31
        this.memberId = memberId;
32
        this.loans = new List<Loan>();
33
    }
34

35
    public override string GetRole()
36
    {
37
        return "Member";
38
    }
39

40
    // DEPENDENCY - uses Book and Librarian temporarily
41
    public Loan BorrowBook(Book book, Librarian librarian)
42
    {
43
        Loan loan = new Loan(this, book, librarian);
44
        loans.Add(loan);  // COMPOSITION
45
        return loan;
46
    }
47
}
48

49
// Inheritance - Librarian IS-A Person
50
public class Librarian : Person
51
{
52
    private string employeeId;
53

54
    public Librarian(string name, string email, string employeeId)
55
        : base(name, email)
56
    {
57
        this.employeeId = employeeId;
58
    }
59

60
    public override string GetRole()
61
    {
62
        return "Librarian";
63
    }
64

65
    // DEPENDENCY - uses Loan temporarily
66
    public void ProcessReturn(Loan loan)
67
    {
68
        loan.ReturnBook();
69
        if (loan.IsOverdue())
70
        {
71
            Fine fine = new Fine(loan);  // COMPOSITION - fine created with loan
72
            loan.SetFine(fine);
73
        }
74
    }
75
}
76

77
// ========== COMPOSITION ==========
78
public class Book
79
{
80
    private string isbn;
81
    private string title;
82
    private string author;
83
    public bool Available { get; set; }
84

85
    public Book(string isbn, string title, string author)
86
    {
87
        this.isbn = isbn;
88
        this.title = title;
89
        this.author = author;
90
        this.Available = true;
91
    }
92

93
    public string GetTitle() => title;
94
    public string GetIsbn() => isbn;
95
}
96

97
// COMPOSITION - Loan belongs to Member
98
public class Loan
99
{
100
    private Member member;      // ASSOCIATION - references member
101
    private Book book;          // ASSOCIATION - references book
102
    private Librarian librarian; // ASSOCIATION - references librarian
103
    private DateTime borrowDate;
104
    private DateTime dueDate;
105
    private DateTime? returnDate;
106
    private Fine fine;          // COMPOSITION - optional fine
107

108
    public Loan(Member member, Book book, Librarian librarian)
109
    {
110
        this.member = member;
111
        this.book = book;
112
        this.librarian = librarian;
113
        this.borrowDate = DateTime.Now;
114
        this.dueDate = borrowDate.AddDays(14);
115
        this.returnDate = null;
116
    }
117

118
    public void ReturnBook()
119
    {
120
        this.returnDate = DateTime.Now;
121
        book.Available = true;
122
    }
123

124
    public bool IsOverdue()
125
    {
126
        if (returnDate.HasValue)
127
        {
128
            return returnDate.Value > dueDate;
129
        }
130
        return DateTime.Now > dueDate;
131
    }
132

133
    public void SetFine(Fine fine)
134
    {
135
        this.fine = fine;
136
    }
137

138
    public Fine GetFine() => fine;
139

140
    internal DateTime GetDueDate() => dueDate;
141
}
142

143
// COMPOSITION - Fine belongs to Loan
144
public class Fine
145
{
146
    private Loan loan;  // ASSOCIATION - references loan
147
    public double Amount { get; private set; }
148

149
    public Fine(Loan loan)
150
    {
151
        this.loan = loan;
152
        int daysOverdue = (int)(DateTime.Now - loan.GetDueDate()).TotalDays;
153
        this.Amount = daysOverdue * 0.50;  // $0.50 per day
154
    }
155
}
156

157
// ========== COMPOSITION & AGGREGATION ==========
158
public class Library
159
{
160
    private string name;
161
    private List<Book> books;      // COMPOSITION - books belong to library
162
    private List<Member> members;  // AGGREGATION - members can exist independently
163
    private List<Librarian> librarians; // AGGREGATION - librarians can exist independently
164

165
    public Library(string name)
166
    {
167
        this.name = name;
168
        this.books = new List<Book>();
169
        this.members = new List<Member>();
170
        this.librarians = new List<Librarian>();
171
    }
172

173
    public void AddBook(Book book)
174
    {
175
        books.Add(book);  // COMPOSITION
176
    }
177

178
    public void RegisterMember(Member member)
179
    {
180
        members.Add(member);  // AGGREGATION
181
    }
182

183
    public void HireLibrarian(Librarian librarian)
184
    {
185
        librarians.Add(librarian);  // AGGREGATION
186
    }
187

188
    // DEPENDENCY - uses string parameter
189
    public Book FindBook(string isbn)
190
    {
191
        return books.FirstOrDefault(book => book.GetIsbn() == isbn);
192
    }
193
}
194

195
// ========== USAGE ==========
196
class Program
197
{
198
    static void Main()
199
    {
200
        // Create library
201
        Library library = new Library("City Library");
202

203
        // Create books (COMPOSITION - belong to library)
204
        Book book1 = new Book("12345", "Python Guide", "Author A");
205
        Book book2 = new Book("67890", "Java Guide", "Author B");
206
        library.AddBook(book1);
207
        library.AddBook(book2);
208

209
        // Create members (AGGREGATION - can exist independently)
210
        Member member1 = new Member("Alice", "[email protected]", "M001");
211
        Member member2 = new Member("Bob", "[email protected]", "M002");
212
        library.RegisterMember(member1);
213
        library.RegisterMember(member2);
214

215
        // Create librarian (AGGREGATION)
216
        Librarian librarian = new Librarian("Carol", "[email protected]", "L001");
217
        library.HireLibrarian(librarian);
218

219
        // Member borrows book (creates ASSOCIATION and COMPOSITION)
220
        Loan loan = member1.BorrowBook(book1, librarian);
221
        Console.WriteLine($"{member1.Name} borrowed {book1.GetTitle()}");
222

223
        // Librarian processes return (uses DEPENDENCY)
224
        librarian.ProcessReturn(loan);
225
        Fine fine = loan.GetFine();
226
        Console.WriteLine($"Book returned. Fine: ${(fine != null ? fine.Amount : 0):F2}");
227
    }
228
}

1
package main
2

3
import (
4
  "fmt"
5
  "math"
6
  "time"
7
)
8

9
// ========== INHERITANCE ==========
10
type Person interface {
11
  GetRole() string
12
  Name() string
13
}
14

15
type personBase struct {
16
  name, email string
17
}
18

19
func (p *personBase) Name() string { return p.name }
20

21
// Member IS-A Person (interface satisfaction)
22
type Member struct {
23
  personBase
24
  memberID string
25
  loans    []*Loan // COMPOSITION - loans belong to member
26
}
27

28
func NewMember(name, email, memberID string) *Member {
29
  return &Member{
30
    personBase: personBase{name: name, email: email},
31
    memberID:   memberID,
32
    loans:      []*Loan{},
33
  }
34
}
35

36
func (m *Member) GetRole() string { return "Member" }
37

38
// DEPENDENCY - uses Book and Librarian temporarily
39
func (m *Member) BorrowBook(book *Book, librarian *Librarian) *Loan {
40
  loan := NewLoan(m, book, librarian)
41
  m.loans = append(m.loans, loan) // COMPOSITION
42
  return loan
43
}
44

45
// Librarian IS-A Person
46
type Librarian struct {
47
  personBase
48
  employeeID string
49
}
50

51
func NewLibrarian(name, email, employeeID string) *Librarian {
52
  return &Librarian{
53
    personBase: personBase{name: name, email: email},
54
    employeeID: employeeID,
55
  }
56
}
57

58
func (l *Librarian) GetRole() string { return "Librarian" }
59

60
// DEPENDENCY - uses Loan temporarily
61
func (l *Librarian) ProcessReturn(loan *Loan) {
62
  loan.ReturnBook()
63
  if loan.IsOverdue() {
64
    fine := NewFine(loan) // COMPOSITION - fine created with loan
65
    loan.SetFine(fine)
66
  }
67
}
68

69
var _ Person = (*Member)(nil)
70
var _ Person = (*Librarian)(nil)
71

72
// ========== COMPOSITION ==========
73
type Book struct {
74
  isbn      string
75
  title     string
76
  author    string
77
  Available bool
78
}
79

80
func NewBook(isbn, title, author string) *Book {
81
  return &Book{isbn: isbn, title: title, author: author, Available: true}
82
}
83

84
func (b *Book) GetTitle() string { return b.title }
85
func (b *Book) GetIsbn() string  { return b.isbn }
86

87
// COMPOSITION - Loan belongs to Member
88
type Loan struct {
89
  member           *Member
90
  book             *Book
91
  librarian        *Librarian
92
  borrowDate       time.Time
93
  dueDate          time.Time
94
  returnDate       *time.Time
95
  fine             *Fine // COMPOSITION - optional fine
96
}
97

98
func NewLoan(member *Member, book *Book, librarian *Librarian) *Loan {
99
  now := time.Now()
100
  return &Loan{
101
    member:     member,
102
    book:       book,
103
    librarian:  librarian,
104
    borrowDate: now,
105
    dueDate:    now.AddDate(0, 0, 14),
106
    returnDate: nil,
107
    fine:       nil,
108
  }
109
}
110

111
func (l *Loan) ReturnBook() {
112
  now := time.Now()
113
  l.returnDate = &now
114
  l.book.Available = true
115
}
116

117
func (l *Loan) IsOverdue() bool {
118
  if l.returnDate != nil {
119
    return l.returnDate.After(l.dueDate)
120
  }
121
  return time.Now().After(l.dueDate)
122
}
123

124
func (l *Loan) SetFine(f *Fine) {
125
  l.fine = f
126
}
127

128
func (l *Loan) GetFine() *Fine { return l.fine }
129

130
func (l *Loan) getDueDate() time.Time { return l.dueDate }
131

132
// COMPOSITION - Fine belongs to Loan
133
type Fine struct {
134
  loan   *Loan // ASSOCIATION - references loan
135
  Amount float64
136
}
137

138
func NewFine(loan *Loan) *Fine {
139
  daysOverdue := int(math.Ceil(time.Since(loan.getDueDate()).Hours() / 24.0))
140
  if daysOverdue < 0 {
141
    daysOverdue = 0
142
  }
143
  return &Fine{
144
    loan:   loan,
145
    Amount: float64(daysOverdue) * 0.50, // $0.50 per day
146
  }
147
}
148

149
// ========== COMPOSITION & AGGREGATION ==========
150
type Library struct {
151
  name         string
152
  books        []*Book      // COMPOSITION - books belong to library
153
  members      []*Member    // AGGREGATION
154
  librarians   []*Librarian // AGGREGATION
155
}
156

157
func NewLibrary(name string) *Library {
158
  return &Library{
159
    name:       name,
160
    books:      []*Book{},
161
    members:    []*Member{},
162
    librarians: []*Librarian{},
163
  }
164
}
165

166
func (lib *Library) AddBook(book *Book) {
167
  lib.books = append(lib.books, book) // COMPOSITION
168
}
169

170
func (lib *Library) RegisterMember(m *Member) {
171
  lib.members = append(lib.members, m) // AGGREGATION
172
}
173

174
func (lib *Library) HireLibrarian(l *Librarian) {
175
  lib.librarians = append(lib.librarians, l) // AGGREGATION
176
}
177

178
func (lib *Library) FindBook(isbn string) *Book {
179
  for _, b := range lib.books {
180
    if b.GetIsbn() == isbn {
181
      return b
182
    }
183
  }
184
  return nil
185
}
186

187
func main() {
188
  library := NewLibrary("City Library")
189

190
  book1 := NewBook("12345", "Python Guide", "Author A")
191
  book2 := NewBook("67890", "Java Guide", "Author B")
192
  library.AddBook(book1)
193
  library.AddBook(book2)
194

195
  member1 := NewMember("Alice", "[email protected]", "M001")
196
  member2 := NewMember("Bob", "[email protected]", "M002")
197
  library.RegisterMember(member1)
198
  library.RegisterMember(member2)
199

200
  librarian := NewLibrarian("Carol", "[email protected]", "L001")
201
  library.HireLibrarian(librarian)
202

203
  loan := member1.BorrowBook(book1, librarian)
204
  fmt.Printf("%s borrowed %s\n", member1.Name(), book1.GetTitle())
205

206
  librarian.ProcessReturn(loan)
207
  var fineAmt float64
208
  if f := loan.GetFine(); f != nil {
209
    fineAmt = f.Amount
210
  }
211
  fmt.Printf("Book returned. Fine: $%.2f\n", fineAmt)
212

213
  _ = book2
214
  _ = member2
215
}

1
// ========== INHERITANCE-LIKE POLYMORPHISM ==========
2
trait Person {
3
    fn role(&self) -> &'static str;
4
    fn name(&self) -> &str;
5
}
6

7
struct Member {
8
    name: String,
9
    email: String,
10
    member_id: String,
11
}
12

13
impl Member {
14
    fn new(name: impl Into<String>, email: impl Into<String>, member_id: impl Into<String>) -> Self {
15
        Self {
16
            name: name.into(),
17
            email: email.into(),
18
            member_id: member_id.into(),
19
        }
20
    }
21

22
    // DEPENDENCY - uses Book and Librarian temporarily to create a Loan
23
    fn borrow_book<'a>(&'a self, book: &'a mut Book, librarian: &'a Librarian) -> Loan<'a> {
24
        Loan::new(self, book, librarian)
25
    }
26
}
27

28
impl Person for Member {
29
    fn role(&self) -> &'static str {
30
        "Member"
31
    }
32

33
    fn name(&self) -> &str {
34
        &self.name
35
    }
36
}
37

38
struct Librarian {
39
    name: String,
40
    email: String,
41
    employee_id: String,
42
}
43

44
impl Librarian {
45
    fn new(name: impl Into<String>, email: impl Into<String>, employee_id: impl Into<String>) -> Self {
46
        Self {
47
            name: name.into(),
48
            email: email.into(),
49
            employee_id: employee_id.into(),
50
        }
51
    }
52

53
    // DEPENDENCY - uses Loan temporarily
54
    fn process_return(&self, loan: &mut Loan<'_>) {
55
        loan.return_book();
56
        if loan.is_overdue() {
57
            loan.fine = Some(Fine::new(loan));
58
        }
59
    }
60
}
61

62
impl Person for Librarian {
63
    fn role(&self) -> &'static str {
64
        "Librarian"
65
    }
66

67
    fn name(&self) -> &str {
68
        &self.name
69
    }
70
}
71

72
// ========== COMPOSITION ==========
73
struct Book {
74
    isbn: String,
75
    title: String,
76
    author: String,
77
    available: bool,
78
}
79

80
impl Book {
81
    fn new(isbn: impl Into<String>, title: impl Into<String>, author: impl Into<String>) -> Self {
82
        Self {
83
            isbn: isbn.into(),
84
            title: title.into(),
85
            author: author.into(),
86
            available: true,
87
        }
88
    }
89
}
90

91
struct Loan<'a> {
92
    member: &'a Member,       // ASSOCIATION - references member
93
    book: &'a mut Book,       // ASSOCIATION - references book
94
    librarian: &'a Librarian, // ASSOCIATION - references librarian
95
    fine: Option<Fine>,       // COMPOSITION - optional fine
96
    returned: bool,
97
}
98

99
impl<'a> Loan<'a> {
100
    fn new(member: &'a Member, book: &'a mut Book, librarian: &'a Librarian) -> Self {
101
        book.available = false;
102
        Self {
103
            member,
104
            book,
105
            librarian,
106
            fine: None,
107
            returned: false,
108
        }
109
    }
110

111
    fn return_book(&mut self) {
112
        self.returned = true;
113
        self.book.available = true;
114
    }
115

116
    fn is_overdue(&self) -> bool {
117
        false // Keep the example focused on relationships.
118
    }
119
}
120

121
struct Fine {
122
    amount: f64,
123
}
124

125
impl Fine {
126
    fn new(_loan: &Loan<'_>) -> Self {
127
        Self { amount: 0.50 }
128
    }
129
}
130

131
// ========== COMPOSITION & AGGREGATION ==========
132
struct Library<'a> {
133
    name: String,
134
    books: Vec<Book>,              // COMPOSITION - books belong to library
135
    members: Vec<&'a Member>,      // AGGREGATION - members can exist independently
136
    librarians: Vec<&'a Librarian>, // AGGREGATION - librarians can exist independently
137
}
138

139
impl<'a> Library<'a> {
140
    fn new(name: impl Into<String>) -> Self {
141
        Self {
142
            name: name.into(),
143
            books: Vec::new(),
144
            members: Vec::new(),
145
            librarians: Vec::new(),
146
        }
147
    }
148

149
    fn add_book(&mut self, book: Book) {
150
        self.books.push(book); // COMPOSITION
151
    }
152

153
    fn register_member(&mut self, member: &'a Member) {
154
        self.members.push(member); // AGGREGATION
155
    }
156

157
    fn hire_librarian(&mut self, librarian: &'a Librarian) {
158
        self.librarians.push(librarian); // AGGREGATION
159
    }
160

161
    fn find_book_mut(&mut self, isbn: &str) -> Option<&mut Book> {
162
        self.books.iter_mut().find(|book| book.isbn == isbn)
163
    }
164
}
165

166
fn main() {
167
    let member1 = Member::new("Alice", "[email protected]", "M001");
168
    let member2 = Member::new("Bob", "[email protected]", "M002");
169
    let librarian = Librarian::new("Carol", "[email protected]", "L001");
170

171
    let mut library = Library::new("City Library");
172
    library.add_book(Book::new("12345", "Python Guide", "Author A"));
173
    library.add_book(Book::new("67890", "Java Guide", "Author B"));
174
    library.register_member(&member1);
175
    library.register_member(&member2);
176
    library.hire_librarian(&librarian);
177

178
    let book = library.find_book_mut("12345").expect("book exists");
179
    let mut loan = member1.borrow_book(book, &librarian);
180
    println!("{} borrowed {}", loan.member.name(), loan.book.title);
181

182
    librarian.process_return(&mut loan);
183
    let fine_amount = loan.fine.as_ref().map_or(0.0, |fine| fine.amount);
184
    println!("Book returned. Fine: ${:.2}", fine_amount);
185
}

Relationship Summary

Library system combining inheritance, composition, aggregation, association and dependency across Person, Member, Librarian, Book, Loan and Fine

Relationship Breakdown

1. Inheritance (Person → Member, Librarian)

Why: Both share common attributes (name, email) and have roles
Type: “Is-a” relationship

2. Composition (Library → Book, Member → Loan, Loan → Fine)

Why: Books are part of library, loans belong to members, fines belong to loans
Type: Strong ownership, cannot exist independently

3. Aggregation (Library → Member, Library → Librarian)

Why: Members and librarians can exist independently (can transfer/leave)
Type: Weak ownership, independent lifecycle

4. Association (Loan → Member, Book, Librarian)

Why: Loan references these classes but doesn’t own them
Type: “Knows-a” relationship

5. Dependency (Member → Book, Librarian → Loan)

Why: Used temporarily as method parameters
Type: Temporary use, no storage

Key Takeaways

💡 Time to Practice!

Now that you understand the concepts, put them into practice with our interactive playground. Build UML diagrams, write code, and get AI-powered feedback.

Browse All Problems

Share feedback or report an issue