Aggregation

// ── Aggregation: University has Departments, but Departments ─────────
// exist independently — they are passed in, not created inside: ───────

public class Department {
    private String          name;
    private String          building;
    private List<String>    courses;

    public Department(String name, String building, List<String> courses) {
        this.name     = name;
        this.building = building;
        this.courses  = new ArrayList<>(courses);
    }

    public String getName()     { return name;     }
    public String getBuilding() { return building; }
    public List<String> getCourses() { return new ArrayList<>(courses); }

    @Override
    public String toString() {
        return "Department{" + name + ", " + building + "}";
    }
}

public class University {
    private String            name;
    private List<Department>  departments = new ArrayList<>();

    public University(String name) {
        this.name = name;
    }

    // Aggregation: Department is passed in, not created here.
    // University does NOT control Department's lifecycle.
    public void addDepartment(Department department) {
        departments.add(department);
    }

    public void removeDepartment(Department department) {
        departments.remove(department);
        // Department is NOT destroyed — it continues to exist
        // and can be added to another University.
    }

    public List<Department> getDepartments() {
        return new ArrayList<>(departments);
    }

    public void printStructure() {
        System.out.println("University: " + name);
        departments.forEach(d ->
            System.out.println("  - " + d.getName() +
                               " (" + d.getBuilding() + ")"));
    }
}

// ── Departments created independently, shared across universities: ────
Department cs   = new Department("Computer Science", "Tech Block",
                      List.of("Algorithms", "Databases", "AI"));
Department math = new Department("Mathematics", "Science Block",
                      List.of("Calculus", "Linear Algebra", "Statistics"));
Department phys = new Department("Physics", "Science Block",
                      List.of("Mechanics", "Quantum", "Thermodynamics"));

University uni1 = new University("University of Example");
uni1.addDepartment(cs);
uni1.addDepartment(math);

University uni2 = new University("Institute of Technology");
uni2.addDepartment(cs);      // same cs object — shared across universities
uni2.addDepartment(phys);

uni1.printStructure();
uni2.printStructure();

// If uni1 is garbage-collected, cs and math still exist.
// uni2 still holds a reference to cs — it is alive.
uni1 = null;
System.out.println("CS still exists: " + cs.getName());  // Computer Science

// ── Aggregation through constructor injection: ───────────────────────
public class Logger {
    private final String name;

    public Logger(String name) { this.name = name; }

    public void log(String level, String message) {
        System.out.printf("[%s] [%s] %s%n",
            java.time.LocalTime.now(), level, message);
    }

    public void close() {
        System.out.println("Logger " + name + " closed");
    }
}

public class UserRepository {
    private final Logger logger;        // aggregation — Logger passed in

    // Constructor injection — Logger is NOT created here:
    public UserRepository(Logger logger) {
        this.logger = Objects.requireNonNull(logger, "logger required");
    }

    public void save(String username) {
        logger.log("INFO", "Saving user: " + username);
        // ... actual save logic ...
        logger.log("INFO", "User saved: " + username);
    }

    public String findByUsername(String username) {
        logger.log("INFO", "Finding user: " + username);
        return username;    // simplified
    }

    // UserRepository does NOT close the logger — it doesn't own it.
    // The Logger may be shared with other classes.
}

public class OrderRepository {
    private final Logger logger;        // same aggregation pattern

    public OrderRepository(Logger logger) {
        this.logger = Objects.requireNonNull(logger, "logger required");
    }

    public void save(String orderId) {
        logger.log("INFO", "Saving order: " + orderId);
    }
}

// ── Shared logger — aggregation allows sharing: ───────────────────────
Logger sharedLogger = new Logger("AppLogger");

// Both repositories use the same logger — aggregation (not composition)
// makes this sharing safe and natural:
UserRepository  userRepo  = new UserRepository(sharedLogger);
OrderRepository orderRepo = new OrderRepository(sharedLogger);

userRepo.save("alice");
orderRepo.save("ORD-001");

// sharedLogger is still active — neither repository closed it.
// The application code that created it is responsible for closing:
sharedLogger.close();   // closed only when the application is done with it

// ── Comparing all three relationships side by side: ──────────────────

// ASSOCIATION — uses, no ownership, fully independent:
public class Driver {
    public void drive(Car car) {   // Car is a parameter — no field
        System.out.println("Driving: " + car.getModel());
    }
    // Driver has no field holding Car — the association is temporary,
    // existing only for the duration of the method call.
}

// AGGREGATION — has-a, parts exist independently, passed in:
public class Playlist {
    private String       name;
    private List<Song>   songs;    // Songs are passed in, not created here

    public Playlist(String name) {
        this.name  = name;
        this.songs = new ArrayList<>();
    }

    public void addSong(Song song) {
        songs.add(song);   // Song already exists — just adding a reference
    }

    public void removeSong(Song song) {
        songs.remove(song);  // Song continues to exist after removal
    }
    // Deleting a Playlist does not delete the Songs.
    // The same Song can appear in many Playlists.
}

// COMPOSITION — owns parts, creates them, destroys them with itself:
public class House {
    private final Room livingRoom;   // Rooms created inside House
    private final Room bedroom;
    private final Room kitchen;

    public House(String address) {
        // Rooms are created BY House — they are owned parts:
        this.livingRoom = new Room("Living Room", 25.0);
        this.bedroom    = new Room("Bedroom",     18.0);
        this.kitchen    = new Room("Kitchen",     12.0);
    }
    // When House is garbage-collected, all Room objects become
    // unreachable (assuming no external references) and are GC'd too.
    // The Rooms have no meaning or existence outside this House.
}

// ── Decision guide: ───────────────────────────────────────────────────
//
// Can the part exist without the whole?
//   Yes → Association or Aggregation
//   No  → Composition
//
// Is the part created inside the whole's constructor?
//   Yes → Composition (strong ownership)
//   No  → Aggregation (part passed in, weak ownership)
//
// Does the whole have a field storing the part?
//   No  → Association (temporary or method-scoped)
//   Yes → Aggregation or Composition