1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// AGGREGATION: Department ◇— Professor
// Professors exist independently and can belong to multiple departments
 
public class Professor {
    private String professorId;
    private String name;
    private String specialization;
    
    public Professor(String professorId, String name, String specialization) {
        this.professorId = professorId;
        this.name = name;
        this.specialization = specialization;
    }
    
    // Professor exists independently—has its own identity and lifecycle
    // Can be created without any Department
    // Can be associated with multiple Departments
    
    public String getName() { return name; }
    public String getSpecialization() { return specialization; }
}
 
public class Department {
    private String departmentId;
    private String name;
    private List<Professor> professors;  // Aggregation: References, not ownership
    
    public Department(String departmentId, String name) {
        this.departmentId = departmentId;
        this.name = name;
        this.professors = new ArrayList<>();
    }
    
    public void addProfessor(Professor professor) {
        // Professor is added—not created here
        // Professor existed before and will exist after
        if (!professors.contains(professor)) {
            professors.add(professor);
        }
    }
    
    public void removeProfessor(Professor professor) {
        // Removing doesn't destroy the Professor
        // Professor continues to exist, just no longer in this Department
        professors.remove(professor);
    }
    
    public List<Professor> getProfessors() {
        return Collections.unmodifiableList(professors);
    }
    
    public void dissolve() {
        // When Department is dissolved...
        professors.clear();  // Clear references
        // But Professors are NOT destroyed—they continue to exist!
        // They might be reassigned to other departments
    }
}
 
// Usage demonstrates independent lifecycle:
public class UniversityExample {
    public static void main(String[] args) {
        // Professors exist before any Department
        Professor alice = new Professor("P001", "Alice Smith", "Machine Learning");
        Professor bob = new Professor("P002", "Bob Johnson", "Databases");
        Professor carol = new Professor("P003", "Carol Williams", "Networks");
        
        // Departments are created
        Department cs = new Department("D001", "Computer Science");
        Department ai = new Department("D002", "Artificial Intelligence");
        
        // Professors added to departments
        cs.addProfessor(alice);
        cs.addProfessor(bob);
        ai.addProfessor(alice);  // Alice is in BOTH departments!
        ai.addProfessor(carol);
        
        // AI department is dissolved
        ai.dissolve();
        
        // But Alice and Carol still exist!
        System.out.println(alice.getName());  // Works fine
        System.out.println(carol.getName());  // Works fine
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

-- AGGREGATION: Professors exist independently of Departments
-- Many-to-Many relationship with independent entities
 
-- Professors table: Independent entity with its own primary key
CREATE TABLE professors (
    professor_id VARCHAR(36) PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    specialization VARCHAR(255),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    -- Note: No department_id here! Professors don't "belong" to one department
);
 
-- Departments table: Independent entity
CREATE TABLE departments (
    department_id VARCHAR(36) PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    budget DECIMAL(15,2)
);
 
-- Junction table for Many-to-Many aggregation relationship
CREATE TABLE department_professors (
    department_id VARCHAR(36) REFERENCES departments(department_id),
    professor_id VARCHAR(36) REFERENCES professors(professor_id),
    role VARCHAR(50) DEFAULT 'member',  -- Extra data about the relationship
    joined_date DATE,
    PRIMARY KEY (department_id, professor_id)
    -- Note: ON DELETE CASCADE applies to the relationship, not the Professor!
);
 
-- CONTRAST WITH COMPOSITION: Rooms cannot exist without House
-- This would use embedded foreign key with ON DELETE CASCADE
 
CREATE TABLE houses (
    house_id VARCHAR(36) PRIMARY KEY,
    address VARCHAR(255) NOT NULL
);
 
CREATE TABLE rooms (
    room_id VARCHAR(36) PRIMARY KEY,
    house_id VARCHAR(36) NOT NULL REFERENCES houses(house_id) ON DELETE CASCADE,
    -- ON DELETE CASCADE: If house is deleted, rooms are deleted too
    room_name VARCHAR(100),
    square_feet INTEGER
    -- room_id belongs to exactly one house_id
);