Agrégation vs Composition

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 48 sur 87.

L’agrégation et la composition sont toutes deux des formes de relations « possède un », mais elles diffèrent sur un aspect crucial : la propriété et la dépendance du cycle de vie.

En composition, l’objet contenu ne peut pas exister indépendamment du conteneur. Lorsque le conteneur est détruit, ses parties le sont aussi. Pense à une House et à ses objets Room : les pièces n’existent pas sans la maison :

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 crée les pièces et en est propriétaire
        }
    }
}

Dans l’agrégation, l’objet contenu peut exister indépendamment. Le conteneur utilise l’objet, mais ne contrôle pas son cycle de vie. Prenons une Team et ses objets Player : les joueurs existent même sans équipe :

class Team {
    private List<Player> players;
    
    public Team() {
        players = new ArrayList<>();
    }
    
    public void addPlayer(Player player) {
        players.add(player);  // Team utilise des joueurs existants
    }
}

La distinction essentielle : dans la composition, le conteneur crée ses parties en interne. Dans l’agrégation, les objets sont transmis depuis l’extérieur. Quand une Team est supprimée, les objets Player existent toujours. Quand une House est supprimée, ses objets Room disparaissent aussi.

Défi

Facile

Construisons un système de cours universitaires qui illustre à la fois l’agrégation et la composition. Tu verras comment un Course possède ses propres objets Lecture (composition), tandis qu’il ne fait que référencer des objets Professor qui existent indépendamment (agrégation).

Tu organiseras ton code dans quatre fichiers :

Professor.java : crée une classe représentant un professeur qui peut exister indépendamment de tout cours. Un professeur possède deux champs privés : name (String) et department (String). Ajoute un constructeur pour initialiser les deux champs et des méthodes getter pour chacun. Redéfinis toString() pour qu’elle renvoie : Prof. [name] ([department])
Lecture.java : crée une classe représentant un cours magistral qui n’a de sens que dans le cadre d’un cours. Un cours magistral possède deux champs privés : topic (String) et durationMinutes (int). Ajoute un constructeur et des getters. Redéfinis toString() pour qu’elle renvoie : Lecture: [topic] ([durationMinutes] min)
Course.java : c’est ici que tu vas illustrer les deux relations ! Un cours possède trois champs privés : title (String), professor (Professor — agrégation) et lectures (un tableau d’objets Lecture — composition).
Le constructeur prend le titre du cours, un objet Professor (transmis de l’extérieur — agrégation) et le nombre de cours magistraux. Dans le constructeur, crée le tableau Lecture et remplis-le avec de nouveaux objets Lecture. Pour chaque cours magistral à l’index i, crée-le avec le sujet "Topic " + (i + 1) et une durée de 45 minutes. Cette création interne illustre la composition.

Ajoute une méthode getInfo() qui renvoie une chaîne String sur plusieurs lignes :
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Ajoute aussi une méthode listLectures() qui renvoie une chaîne String avec le toString() de chaque cours magistral sur sa propre ligne.
Main.java : rassemble tout ! Tu recevras quatre entrées : le nom du professeur (String), le département du professeur (String), le titre du cours (String) et le nombre de cours magistraux (int).
Commence par créer un Professor avec le nom et le département fournis. Ce professeur existe indépendamment. Crée ensuite un Course en lui transmettant le titre, le professeur (agrégation) et le nombre de cours magistraux (le cours créera ses propres cours magistraux en interne — composition).

Affiche le résultat de getInfo(), puis affiche une ligne vide, puis affiche le résultat de listLectures().

Tu recevras quatre entrées dans l’ordre suivant : le nom du professeur, le département, le titre du cours et le nombre de cours magistraux.

Remarque la différence essentielle : le Professor est créé à l’extérieur et transmis au Course (agrégation : le professeur pourrait enseigner d’autres cours ou exister sans celui-ci). Les Lecture sont créés dans le constructeur du Course (composition). Ils appartiennent exclusivement à ce cours et n’existeraient pas sans lui.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les données d’entrée
        String professorName = scanner.nextLine();
        String department = scanner.nextLine();
        String courseTitle = scanner.nextLine();
        int numberOfLectures = scanner.nextInt();
        
        // TODO: Créer un objet Professor (existe indépendamment - agrégation)
        
        // TODO: Créer un objet Course en lui passant le professeur (agrégation)
        // Le cours créera ses propres séances en interne (composition)
        
        // TODO: Afficher le résultat de getInfo()
        
        // TODO: Afficher une ligne vide
        
        // TODO: Afficher le résultat de listLectures()
        
    }
}