Agregación vs. Composición

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 48 de 87.

Tanto la agregación como la composición son formas de relaciones «has-a», pero difieren en un aspecto crucial: la propiedad y la dependencia del ciclo de vida.

En la composición, el objeto contenido no puede existir independientemente del contenedor. Cuando se destruye el contenedor, también lo hacen sus partes. Piensa en una House y sus objetos Room: las habitaciones no existen sin la casa:

class House {
    private Room[] rooms;
    
    public House(int numRooms) {
        rooms = new Room[numRooms];
        for (int i = 0; i < numRooms; i++) {
            rooms[i] = new Room();  // House crea y posee rooms
        }
    }
}

En la agregación, el objeto contenido puede existir de forma independiente. El contenedor utiliza el objeto, pero no controla su ciclo de vida. Considera un Team y sus objetos Player: los jugadores existen incluso sin un equipo:

class Team {
    private List<Player> players;
    
    public Team() {
        players = new ArrayList<>();
    }
    
    public void addPlayer(Player player) {
        players.add(player);  // Team usa jugadores existentes
    }
}

La distinción clave: en la composición, el contenedor crea sus partes internamente. En la agregación, los objetos se pasan desde el exterior. Cuando se elimina un Team, los objetos Player todavía existen. Cuando se elimina un House, sus objetos Room también desaparecen.

Desafío

Fácil

Construyamos un sistema de cursos universitarios que demuestre tanto la agregación como la composición. Verás cómo un Course es propietario de sus objetos Lecture (composición), mientras que solo hace referencia a objetos Professor que existen de forma independiente (agregación).

Organizarás tu código en cuatro archivos:

Professor.java: Crea una clase que represente a un profesor que pueda existir independientemente de cualquier curso. Un Professor tiene dos campos privados: name (String) y department (String). Incluye un constructor para inicializar ambos campos y métodos getter para cada uno. Sobrescribe toString() para que devuelva: Prof. [name] ([department])
Lecture.java: Crea una clase que represente una clase que solo tenga sentido dentro de un curso. Una Lecture tiene dos campos privados: topic (String) y durationMinutes (int). Incluye un constructor y getters. Sobrescribe toString() para que devuelva: Lecture: [topic] ([durationMinutes] min)
Course.java: ¡Aquí demostrarás ambas relaciones! Un Course tiene tres campos privados: title (String), professor (Professor - agregación) y lectures (un array de objetos Lecture - composición).
El constructor recibe el título del curso, un objeto Professor (pasado desde fuera - agregación) y el número de clases. Dentro del constructor, crea el array de Lecture y rellénalo con nuevos objetos Lecture. Para cada clase en el índice i, créala con el tema "Topic " + (i + 1) y una duración de 45 minutos. Esta creación interna demuestra la composición.

Añade un método getInfo() que devuelva un String de varias líneas:
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Añade también un método listLectures() que devuelva un String con el toString() de cada clase en su propia línea.
Main.java: ¡Reúne todos los elementos! Recibirás cuatro entradas: nombre del profesor (String), departamento del profesor (String), título del curso (String) y número de clases (int).
Primero, crea un Professor con el nombre y el departamento proporcionados. Este profesor existe de forma independiente. Después, crea un Course, pasando el título, el profesor (agregación) y el número de clases (el curso creará sus propias clases internamente - composición).

Imprime el resultado de getInfo(), después imprime una línea vacía y, por último, imprime el resultado de listLectures().

Recibirás cuatro entradas en este orden: nombre del profesor, departamento, título del curso y número de clases.

Observa la diferencia clave: el Professor se crea fuera y se pasa al Course (agregación: el profesor podría impartir otros cursos o existir sin este). Las Lecture se crean dentro del constructor de Course (composición. Pertenecen exclusivamente a este curso y no existirían sin él).

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer entradas
        String professorName = scanner.nextLine();
        String department = scanner.nextLine();
        String courseTitle = scanner.nextLine();
        int numberOfLectures = scanner.nextInt();
        
        // TODO: Crear un objeto Professor (existe de forma independiente - agregación)
        
        // TODO: Crear un objeto Course, pasando el professor (agregación)
        // El course creará sus propias lectures internamente (composición)
        
        // TODO: Imprimir el resultado de getInfo()
        
        // TODO: Imprimir una línea vacía
        
        // TODO: Imprimir el resultado de listLectures()
        
    }
}