OOP Relationships

Customer
Order
Product
Payment
Address
ShoppingCart

Customer places Order
Order contains Products
Customer has Address
Order uses Payment
ShoppingCart contains Products

Dog IS-A Animal

Car HAS-A Engine

Student USES-A Teacher

Department HAS-A Employee

House HAS-A Room

Is one thing a type of another thing?

IS-A

Dog IS-A Animal

Does one object contain, own, use, or work with another object?

HAS-A
Association
Aggregation
Composition
Dependency

Dog IS-A Animal
Car IS-A Vehicle
Manager IS-A Employee
Circle IS-A Shape

class Animal {
}

class Dog extends Animal {
}

Dog IS-A Animal

interface Flyable {

    void fly();
}

class Bird
        implements Flyable {

    @Override
    public void fly() {
        System.out.println(
            "Bird flies"
        );
    }
}

Bird IS-A Flyable

class Employee {
}

class Developer
        extends Employee {
}

Employee employee =
    new Developer();

Developer IS-A Employee

class Car extends Engine {
}

class Car {

    private Engine engine;
}

Car HAS-A Engine

Car HAS-A Engine
Student HAS-A Address
Order HAS-A Customer
Computer HAS-A Processor
House HAS-A Room

class Car {

    private Engine engine;
}

class Engine {

    void start() {
        System.out.println(
            "Engine started"
        );
    }
}

class Car {

    private Engine engine;

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

Association
Aggregation
Composition

ownership
lifetime
independence
strength of relationship

Objects know about or interact with each other.

Teacher teaches Student
Doctor treats Patient
Customer contacts SupportAgent
Driver drives Car

class Teacher {

    void teach() {
        System.out.println(
            "Teaching"
        );
    }
}

class Student {

    void learn() {
        System.out.println(
            "Learning"
        );
    }
}

class School {

    void conductClass(
        Teacher teacher,
        Student student
    ) {
        teacher.teach();
        student.learn();
    }
}

Doctor ↔ Patient

Association

class Driver {

    private Car car;

    Driver(Car car) {
        this.car = car;
    }

    void drive() {
        System.out.println(
            "Driver is driving"
        );
    }
}

class Teacher {

    void teach(Student student) {
        System.out.println(
            "Teaching student"
        );
    }
}

class Printer {

    void print(Document document) {

        System.out.println(
            "Printing document"
        );
    }
}

Teacher and Student are associated.

class Passport {

    private String number;

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

class Person {

    private Passport passport;

    Person(Passport passport) {
        this.passport = passport;
    }
}

Teacher
  |
  +---- Student
  +---- Student
  +---- Student

class Teacher {

    private List<Student> students;
}

Students ↔ Courses

Student 1 ─┬─ Course A
           └─ Course B

Student 2 ─┬─ Course A
           └─ Course C

Department HAS-A Employees

class Employee {

    private String name;

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

    void work() {
        System.out.println(
            name + " is working"
        );
    }
}

class Department {

    private List<Employee> employees;

    Department(List<Employee> employees) {
        this.employees = employees;
    }
}

Department contains/aggregates Employees

Employee e1 =
    new Employee("A");

Employee e2 =
    new Employee("B");

List<Employee> employees =
    new ArrayList<>();

employees.add(e1);
employees.add(e2);

Department department =
    new Department(employees);

University
   |
   +── Department
   |
   +── Department

ownership
lifetime
independent existence

House
  |
  +── Room
  +── Room

◇ = aggregation
◆ = composition

class Engine {

    void start() {
        System.out.println(
            "Engine started"
        );
    }
}

class Car {

    private final Engine engine;

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

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

class Car {

    private final Engine engine;

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

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

Aggregation:
whole has parts
parts can exist independently

Composition:
whole strongly owns parts
part lifecycle is tied to whole in the model

Aggregation:
Department ─ Employee

Composition:
House ─ Room

aggregation

composition

classes
objects
fields
constructors
methods
references
collections

class Printer {

    void print(Document document) {
        System.out.println(
            "Printing"
        );
    }
}

class OrderService {

    void process(
        Payment payment
    ) {
        payment.pay();
    }
}

class ReportService {

    void generate() {

        Formatter formatter =
            new Formatter();

        formatter.format();
    }
}

Printer depends on Document.

Association
→ objects have a more lasting relationship/knowledge

Dependency
→ one class temporarily uses another

class Student {

    private Address address;
}

class Printer {

    void print(Document document) {
    }
}

IS-A
→ inheritance/interface relationship

HAS-A
→ object relationship/composition/aggregation/association

Dog IS-A Animal

Car HAS-A Engine

Car
Engine

class Car extends Engine {
}

Car is not an Engine.

class Car {

    private Engine engine;
}

Car has an Engine.

class Car {

    private Engine engine;
    private BrakeSystem brakes;
    private Transmission transmission;
}

interface Engine {

    void start();
}

PetrolEngine
ElectricEngine
HybridEngine

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

composition
+
interface
+
polymorphism

interface Engine {

    void start();
}

class PetrolEngine
        implements Engine {

    @Override
    public void start() {
        System.out.println(
            "Petrol engine started"
        );
    }
}

class ElectricEngine
        implements Engine {

    @Override
    public void start() {
        System.out.println(
            "Electric motor started"
        );
    }
}

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

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

Car petrolCar =
    new Car(
        new PetrolEngine()
    );

Car electricCar =
    new Car(
        new ElectricEngine()
    );

petrolCar.start();
electricCar.start();

Dog IS-A Animal

Car
 |
 +── Engine

Car HAS-A Engine

class Student {

    private Teacher teacher;
}

class Student {

    private Teacher teacher;
}

class Teacher {

    private List<Student> students;
}

Student ─────> Teacher
   ▲             |
   |             ▼
   └──────── Student

more coupling
more code
synchronization problems
recursive toString()
serialization issues
complex updates

student.setTeacher(teacher);
teacher.addStudent(student);

class Student {

    private Teacher teacher;
}

class Teacher {

    private List<Student> students;
}

1 : 1
1 : N
N : 1
N : N

Person ↔ Passport
Teacher ↔ Students
Department ↔ Manager
Students ↔ Courses

class Engine {

    private String serialNumber;

    Engine(String serialNumber) {
        this.serialNumber =
            serialNumber;
    }
}

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

class Student {

    private final String name;

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

class Classroom {

    private final List<Student> students;

    Classroom(List<Student> students) {
        this.students = students;
    }
}

class Student {

    private final List<Course> courses =
        new ArrayList<>();
}

class Course {

    private final List<Student> students =
        new ArrayList<>();
}

Enrollment

date
grade
status
semester

Student
Course

student
course
semester
grade
enrollmentDate

interface Payment {

    void pay(double amount);
}

class OrderService {

    private final Payment payment;

    OrderService(Payment payment) {
        this.payment = payment;
    }
}

class OrderService {

    private final Payment payment;

    OrderService(Payment payment) {
        this.payment = payment;
    }
}

dependency is explicit
dependency can be final
object can be created in a valid state
testing is easier
implementation can be replaced

class ReportService {

    void export(
        Exporter exporter,
        String data
    ) {
        exporter.export(data);
    }
}

class Service {

    private Logger logger;

    void setLogger(Logger logger) {
        this.logger = logger;
    }
}

class OrderService {

    private final StripePayment payment =
        new StripePayment();
}

class OrderService {

    private final Payment payment;

    OrderService(Payment payment) {
        this.payment = payment;
    }
}

testing harder
changes harder
replacement harder
maintenance harder
reuse harder

necessary relationships
+
clear contracts
+
manageable dependencies

no coupling

appropriate coupling

PaymentProcessor
→ payment processing responsibilities

Utility
→ payment
→ email
→ database
→ file
→ user interface
→ random calculations

Coupling
→ relationship between components

Cohesion
→ relatedness of responsibilities inside a component

LOWER unnecessary coupling
HIGHER cohesion

class Car {

    private Engine engine;
}

class Department {

    private final List<Employee> employees;

    List<Employee> getEmployees() {
        return employees;
    }
}

Collections.unmodifiableList(employees)

Engine engine =
    new Engine();

Car car =
    new Car(engine);

engine
car.engine

Engine engine =
    new Engine();

Car car1 =
    new Car(engine);

Car car2 =
    new Car(engine);

Employee employee =
    new Employee("A");

Department d1 =
    new Department(
        List.of(employee)
    );

Department d2 =
    new Department(
        List.of(employee)
    );

class House {

    private final Room kitchen;

    House() {
        kitchen =
            new Room("Kitchen");
    }
}

class Computer {

    private final CPU cpu;
    private final RAM ram;
    private final Storage storage;

    Computer() {
        cpu = new CPU();
        ram = new RAM();
        storage = new Storage();
    }
}

Composition = always use new inside constructor

strong ownership
part-whole meaning
lifecycle relationship

List<Employee>

Employee manager;

Address address;

method parameter
local interaction
stored reference
return value

class CalculatorService {

    void calculate(
        MathEngine engine
    ) {
        engine.calculate();
    }
}

Is the dependency appropriate?
Is it too specific?
Is it easy to replace?

Customer
Order
Product
Payment
Address
ShoppingCart

class Address {

    private final String city;

    Address(String city) {
        this.city = city;
    }
}

class Customer {

    private final Address address;

    Customer(Address address) {
        this.address = address;
    }
}

interface Payment {

    void pay(double amount);
}

class Order {

    private final Payment payment;

    Order(Payment payment) {
        this.payment = payment;
    }

    void checkout(double amount) {
        payment.pay(amount);
    }
}

association/composition-style references
+
interface dependency
+
polymorphism

School
Teacher
Student
Course
Classroom

Teacher ↔ Student
Teacher → Course
Classroom → Students
Student ↔ Course

Who owns whom?
Can the objects exist independently?
Who controls lifecycle?

Employee can move between departments.

Library
Book
Member
Librarian
Loan

Library HAS-A books
Member HAS-A loans
Loan refers to Book
Librarian manages Library

Loan

book
member
issueDate
returnDate
fine

Driver
Passenger
Vehicle
Trip
Payment

Driver HAS-A Vehicle
Trip associates Driver and Passenger
Trip uses Payment

driver
passenger
startLocation
destination
fare
time
status

Customer
Restaurant
Order
FoodItem
DeliveryPartner
Payment
Address

Customer → Order
Order → FoodItem
Order → Payment
Order → Address
Order → DeliveryPartner
Restaurant → FoodItem

Step 1
Ask: Is A a type of B?
        ↓
YES → IS-A

Step 2
If not, ask: Does A contain/have B?
        ↓
YES → HAS-A / whole-part relationship

Step 3
Ask: Can B exist independently?
        ↓
YES → aggregation/association may fit

Step 4
Ask: Is B strongly owned by A?
        ↓
YES → composition may fit

Step 5
Ask: Does A only temporarily use B?
        ↓
YES → dependency may fit

class Calculator {

    int add(int a, int b) {
        return a + b;
    }
}

"These classes are related."

Teacher
Student

class Teacher extends Student {
}

Teacher IS NOT Student

class Teacher {

    void teach(Student student) {
    }
}

Car
Engine

class Car extends Engine {
}

Car IS NOT Engine

class Car {

    private Engine engine;
}

Car HAS-A Engine

Teacher ↔ Student

House → Room

aggregation = weak
composition = strong

Aggregation
→ whole-part relationship
→ part has independent identity/lifetime

Composition
→ whole-part relationship
→ whole controls the part more strongly
→ part lifecycle is tied to whole in the model

House → Room

Room cannot exist independently from House

Department → Employee

employeeId

class ReportService {

    void generate() {

        Formatter formatter =
            new Formatter();

        formatter.format();
    }
}

class Factory {

    Payment createPayment() {
        return new CardPayment();
    }
}

class OrderService {

    double calculateTax(
        double amount
    ) {
        return TaxCalculator.calculate(
            amount
        );
    }
}

Child IS-A Parent

class Animal {
}

class Dog extends Animal {
}

class CardPayment
        implements Payment {
}

CardPayment IS-A Payment

class OrderService {

    private final Payment payment;

    OrderService(Payment payment) {
        this.payment = payment;
    }
}

OrderService HAS-A Payment reference

composition/association
+
interface
+
polymorphism

class ShoppingCart {

    private final DiscountStrategy strategy;

    ShoppingCart(
        DiscountStrategy strategy
    ) {
        this.strategy = strategy;
    }
}

StudentDiscount
FestivalDiscount
PremiumDiscount
NoDiscount

Payment
+
DiscountStrategy
+
Logger
+
FraudChecker

Car
SportsCar
ElectricSportsCar
LuxuryElectricSportsCar

Single Responsibility
→ keep responsibilities focused

Open/Closed
→ extend behavior without excessive modification

Liskov Substitution
→ valid IS-A relationships

Interface Segregation
→ focused contracts

Dependency Inversion
→ depend on abstractions

class Teacher {

    private final String name;

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

    void teach() {
        System.out.println(
            name + " is teaching"
        );
    }
}

class Student {

    private final String name;

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

    void learn() {
        System.out.println(
            name + " is learning"
        );
    }
}

class Classroom {

    void conductClass(
        Teacher teacher,
        Student student
    ) {
        teacher.teach();
        student.learn();
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Teacher teacher =
            new Teacher("Ravi");

        Student student =
            new Student("Aman");

        Classroom classroom =
            new Classroom();

        classroom.conductClass(
            teacher,
            student
        );
    }
}

Ravi is teaching
Aman is learning

import java.util.List;

class Employee {

    private final String name;

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

    void work() {
        System.out.println(
            name + " is working"
        );
    }
}

class Department {

    private final List<Employee> employees;

    Department(
        List<Employee> employees
    ) {
        this.employees = employees;
    }

    void workAll() {

        for (Employee employee :
             employees) {

            employee.work();
        }
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Employee e1 =
            new Employee("Aman");

        Employee e2 =
            new Employee("Riya");

        Department department =
            new Department(
                List.of(e1, e2)
            );

        department.workAll();
    }
}

class Engine {

    void start() {
        System.out.println(
            "Engine started"
        );
    }
}

class Car {

    private final Engine engine;

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

    void start() {
        engine.start();

        System.out.println(
            "Car started"
        );
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Car car =
            new Car();

        car.start();
    }
}

Engine started
Car started

class Document {

    private final String name;

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

class Printer {

    void print(
        Document document
    ) {
        System.out.println(
            "Printing document"
        );
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Document document =
            new Document("Java");

        Printer printer =
            new Printer();

        printer.print(document);
    }
}

interface Engine {

    void start();
}

class PetrolEngine
        implements Engine {

    @Override
    public void start() {
        System.out.println(
            "Petrol engine"
        );
    }
}

class ElectricEngine
        implements Engine {

    @Override
    public void start() {
        System.out.println(
            "Electric engine"
        );
    }
}

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

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

public class Main {

    public static void main(
        String[] args
    ) {

        Car car1 =
            new Car(
                new PetrolEngine()
            );

        Car car2 =
            new Car(
                new ElectricEngine()
            );

        car1.start();
        car2.start();
    }
}

Petrol engine
Electric engine

composition
+
interface
+
polymorphism

interface DiscountStrategy {

    double discount(double amount);
}

class NoDiscount
        implements DiscountStrategy {

    @Override
    public double discount(
        double amount
    ) {
        return 0;
    }
}

class FestivalDiscount
        implements DiscountStrategy {

    @Override
    public double discount(
        double amount
    ) {
        return amount * 0.20;
    }
}

class ShoppingCart {

    private final DiscountStrategy strategy;

    ShoppingCart(
        DiscountStrategy strategy
    ) {
        this.strategy = strategy;
    }

    double finalPrice(
        double amount
    ) {
        return amount -
               strategy.discount(amount);
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        ShoppingCart cart =
            new ShoppingCart(
                new FestivalDiscount()
            );

        System.out.println(
            cart.finalPrice(1000)
        );
    }
}

800.0

import java.util.ArrayList;
import java.util.List;

class Student {

    private final String name;

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

    void show() {
        System.out.println(
            name
        );
    }
}

class Classroom {

    private final List<Student> students =
        new ArrayList<>();

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

    void showStudents() {

        for (Student student :
             students) {

            student.show();
        }
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Classroom classroom =
            new Classroom();

        classroom.addStudent(
            new Student("Aman")
        );

        classroom.addStudent(
            new Student("Riya")
        );

        classroom.showStudents();
    }
}

Aman
Riya

class Student {

    private final String name;

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

class Course {

    private final String name;

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

class Enrollment {

    private final Student student;
    private final Course course;
    private final String semester;

    Enrollment(
        Student student,
        Course course,
        String semester
    ) {
        this.student = student;
        this.course = course;
        this.semester = semester;
    }
}

Student ↔ Course

interface Logger {

    void log(String message);
}

class ConsoleLogger
        implements Logger {

    @Override
    public void log(String message) {
        System.out.println(
            message
        );
    }
}

class Application {

    private final Logger logger;

    Application(Logger logger) {
        this.logger = logger;
    }

    void run() {
        logger.log(
            "Application started"
        );
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Application app =
            new Application(
                new ConsoleLogger()
            );

        app.run();
    }
}

class Doctor {

    void treat(Patient patient) {
        System.out.println(
            "Treating patient"
        );
    }
}

class Patient {

    void recover() {
        System.out.println(
            "Patient recovering"
        );
    }
}

public class Main {

    public static void main(
        String[] args
    ) {

        Doctor doctor =
            new Doctor();

        Patient patient =
            new Patient();

        doctor.treat(patient);
    }
}

class Animal {
}

class Dog extends Animal {
}

Animal animal =
    new Dog();

System.out.println(
    animal instanceof Animal
);

true

class Engine {

    void start() {
        System.out.println("Engine");
    }
}

class Car {

    private final Engine engine =
        new Engine();

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

Car car = new Car();

car.start();

Engine

class Engine {

    void start() {
        System.out.println("Start");
    }
}

class Car {

    private final Engine engine =
        new Engine();

    void start() {
        engine.start();
        System.out.println("Car");
    }
}

new Car().start();

Start
Car

class Teacher {

    void teach() {
        System.out.println("Teach");
    }
}

class Student {
}

class School {

    void run(
        Teacher teacher,
        Student student
    ) {
        teacher.teach();
        System.out.println(
            "Student attends"
        );
    }
}

School school =
    new School();

school.run(
    new Teacher(),
    new Student()
);

Teach
Student attends

class Engine {
}

Engine engine =
    new Engine();

Car car1 =
    new Car(engine);

Car car2 =
    new Car(engine);

1 Engine object
2 Car objects

interface Engine {

    void start();
}

class ElectricEngine
        implements Engine {

    public void start() {
        System.out.println(
            "Electric"
        );
    }
}

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }

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

Car car =
    new Car(
        new ElectricEngine()
    );

car.start();

Electric

interface Discount {

    double apply(double amount);
}

class TenPercent
        implements Discount {

    public double apply(
        double amount
    ) {
        return amount * 0.10;
    }
}

class Cart {

    private final Discount discount;

    Cart(Discount discount) {
        this.discount = discount;
    }

    double price(double amount) {
        return amount -
               discount.apply(amount);
    }
}

System.out.println(
    new Cart(
        new TenPercent()
    ).price(1000)
);

900.0

List<Student> students =
    new ArrayList<>();

students.add(
    new Student()
);

students.add(
    new Student()
);

Classroom
   |
   +── Student
   +── Student

Dog IS-A Animal

Car HAS-A Engine

part can exist independently

part is strongly owned by whole
part lifecycle is tied to whole in the model

Department(List<Employee> employees)

class Car {

    private final Engine engine =
        new Engine();
}

void print(Document document)

method parameters
local variables
method return types
static calls
temporary object usage

OrderService(Payment payment)

testability
flexibility
replaceability
loose coupling

IS-A
→ type relationship

HAS-A
→ object/containment relationship

class Car {

    private Engine engine;
}

high cohesion
+
low unnecessary coupling

Doctor ↔ Patient
Teacher ↔ Student

class Student {

    private Teacher teacher;
}

Student → Teacher
Teacher → Students

Person ↔ Passport

Teacher → Students

Students ↔ Courses

List<Student>
Set<Student>
Map<...>

Dog — Animal
Car — Engine
Developer — Employee
Circle — Shape
Teacher — Student

Dog — Animal       → IS-A
Car — Engine       → No
Developer — Employee → IS-A
Circle — Shape     → IS-A
Teacher — Student  → No

Car — Engine
Computer — CPU
Student — Address
House — Room
Dog — Animal

Car HAS-A Engine
Computer HAS-A CPU
Student HAS-A Address
House HAS-A Room
Dog IS-A Animal

Doctor
Patient
Hospital

Department
Employee

House
Room

addRoom()
showRooms()

Printer
Document

void print(Document document)

Teacher
Student
Classroom

addStudent()
removeStudent()
showStudents()

Student
Course

Student
Course
Enrollment

student
course
semester
grade

Engine
PetrolEngine
ElectricEngine
Car

PaymentStrategy
CardPayment
UpiPayment
WalletPayment
Checkout

Logger
ConsoleLogger
FileLogger
Application

OrderService

CompanyManager

employee management
payment processing
email sending
report generation
database access

EmployeeService
PaymentService
EmailService
ReportService

Student → Teacher

Student ↔ Teacher

Dog / Animal
Car / Engine
Employee / Department
Circle / Shape
Computer / CPU
Teacher / Student

IS-A
HAS-A

Customer
Restaurant
FoodItem
Order
Payment
Address
DeliveryPartner

IS-A
Association
Aggregation
Composition
Dependency

Library
Book
Member
Librarian
Loan

Which object owns which?
Which objects can exist independently?
Which relationships are temporary?
Does Loan represent a relationship?

Driver
Passenger
Vehicle
Trip
Payment

Driver HAS-A Vehicle
Trip associates Driver and Passenger
Trip uses Payment

School
Teacher
Student
Course
Classroom

1. Teacher can teach courses.
2. Students can enroll in courses.
3. Classroom can contain students.
4. Student can have an address.
5. Model relationships correctly.
6. Avoid unnecessary inheritance.
7. Use collections for one-to-many relationships.
8. Use an Enrollment object for relationship-specific information.

Customer
Address
Product
Order
OrderItem
Payment
ShoppingCart

1. Customer has Address.
2. Customer can place Orders.
3. Order contains OrderItems.
4. OrderItem refers to Product.
5. Order uses Payment.
6. Payment must be an interface.
7. Support CardPayment and UpiPayment.
8. Use composition where appropriate.
9. Use dependency injection for Payment.
10. Avoid a large inheritance hierarchy.

Vehicle
Car
Engine
PetrolEngine
ElectricEngine
BrakeSystem

1. Vehicle can be an abstract class or interface where appropriate.
2. Car should have an Engine.
3. Engine should have multiple implementations.
4. Car should receive Engine through constructor injection.
5. Demonstrate runtime polymorphism.
6. Explain why Car should not extend Engine.

Payment
CardPayment
UpiPayment
WalletPayment

DiscountStrategy
NoDiscount
FestivalDiscount
PremiumDiscount

Checkout

Payment
DiscountStrategy

interface
composition
dependency injection
polymorphism
strategy design
loose coupling

Library
Book
Member
Librarian
Loan

Book
Member
issueDate
returnDate
fine

Driver
Passenger
Vehicle
Trip
Payment

driver
passenger
vehicle
payment
fare
status

association
HAS-A
dependency
composition
polymorphism

class Engine {
}

class Car extends Engine {
}

class Car {

    private Engine engine;
}

class Student {

    private Address address;
}

Student HAS-A Address

class Printer {

    void print(Document document) {
    }
}

Printer depends on Document

class House {

    private final Room room;

    House() {
        room = new Room();
    }
}

Employee employee =
    new Employee();

Department department =
    new Department(
        List.of(employee)
    );

class Service {

    private CardPayment payment =
        new CardPayment();
}

class Service {

    private final Payment payment;

    Service(Payment payment) {
        this.payment = payment;
    }
}

PetrolEngine
ElectricEngine
HybridEngine

Car
   |
   +── Engine
          ├── PetrolEngine
          ├── ElectricEngine
          └── HybridEngine

student
course
semester
grade

class Student {
    Teacher teacher;
}

class Teacher {
    List<Student> students;
}

Student says Teacher A
Teacher's list does not contain Student

Person — Passport
Teacher — Students
Students — Courses

Person — Passport
→ one-to-one

Teacher — Students
→ one-to-many

Students — Courses
→ many-to-many

                    OOP RELATIONSHIPS

                         ┌──────────┐
                         │  IS-A    │
                         └────┬─────┘
                              │
                    inheritance / interface
                              │
                              ▼
                         "is a type"

                              OR

                         ┌──────────┐
                         │ HAS-A    │
                         └────┬─────┘
                              │
                ┌─────────────┼─────────────┐
                ▼             ▼             ▼
           Association    Aggregation   Composition
                │             │             │
             interacts    independent    strong ownership
                │             │             │
                └─────────────┴─────────────┘

                         ┌──────────┐
                         │Dependency│
                         └────┬─────┘
                              │
                         temporary use

IS-A
→ type relationship

Association
→ objects know/interact

Aggregation
→ whole-part relationship
→ parts can exist independently

Composition
→ strong whole-part relationship
→ part lifecycle tied to whole in the model

Dependency
→ temporary use

                    Start
                      │
                      ▼
              Is A a type of B?
                 /          \
               YES           NO
                │             │
                ▼             ▼
              IS-A       Does A have/use B?
                              │
                         ┌────┴────┐
                         │         │
                        HAS-A     temporary?
                         │         │
                         ▼         ▼
                    whole-part   Dependency
                         │
                 Can B exist alone?
                    /          \
                  YES           NO
                   │             │
                   ▼             ▼
             Aggregation     Composition

1. Use IS-A for genuine subtype relationships.

2. Do not use inheritance merely to reuse code.

3. Use HAS-A/object relationships when one object contains
   or collaborates with another.

4. Association is the broadest general relationship.

5. Aggregation represents a whole-part relationship where
   parts can independently exist.

6. Composition represents stronger ownership of parts.

7. Dependency represents temporary use.

8. Java has no special aggregation/composition keywords.

9. Fields, constructors, methods, parameters, and references
   are used to implement these relationships.

10. Constructor injection is useful for required dependencies.

11. Interfaces can make composed dependencies replaceable.

12. Prefer high cohesion.

13. Avoid unnecessary coupling.

14. Bidirectional relationships need consistency management.

15. Many-to-many relationships may benefit from relationship
   objects.

16. Do not expose internal mutable collections carelessly.

17. Do not assume that using new automatically means composition.

18. Always consider domain ownership and lifecycle.

19. Favor composition over inheritance when composition better
   represents the design.

20. Good OOP models relationships, not just classes.

IS-A
HAS-A
Association
Aggregation
Composition
Dependency

Dog IS-A Animal

Car HAS-A Engine

Doctor interacts with Patient

Department aggregates Employees

House composes Rooms

Printer depends on Document

inheritance
composition
interfaces
polymorphism
dependency injection

class Car {

    private final Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

interface Engine {
    void start();
}

Car
 |
 | has
 ↓
Engine
 |
 +── PetrolEngine
 +── ElectricEngine

[ ] What is an OOP relationship?
[ ] What is IS-A?
[ ] What is HAS-A?
[ ] What is association?
[ ] What is aggregation?
[ ] What is composition?
[ ] What is dependency?
[ ] IS-A vs HAS-A
[ ] Association vs aggregation
[ ] Aggregation vs composition
[ ] Association vs dependency
[ ] Inheritance vs composition
[ ] Composition over inheritance
[ ] Ownership
[ ] Object lifecycle
[ ] One-to-one
[ ] One-to-many
[ ] Many-to-many
[ ] Unidirectional relationships
[ ] Bidirectional relationships
[ ] Relationship objects
[ ] Coupling
[ ] Cohesion
[ ] Dependency injection
[ ] Constructor injection
[ ] Composition with interfaces
[ ] Interface + polymorphism
[ ] How to choose a relationship
[ ] Common relationship mistakes

Chapter 11
OOP Fundamentals
        ↓
Chapter 12
Classes & Objects
        ↓
Chapter 13
Constructors
        ↓
Chapter 14
this & static
        ↓
Chapter 15
Encapsulation
        ↓
Chapter 16
Inheritance
        ↓
Chapter 17
Method Overloading
        ↓
Chapter 18
Method Overriding
        ↓
Chapter 19
Polymorphism
        ↓
Chapter 20
Abstraction
        ↓
Chapter 21
Interfaces
        ↓
Chapter 22
OOP Relationships
        ↓
Chapter 23
OOP Design

"What relationships exist?"

"How do we design good classes and relationships?"

Coupling
Cohesion
SOLID basics
Good class design
Immutable objects
Common OOP mistakes