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 « has-a », mais elles diffèrent sur un aspect crucial : la propriété et la dépendance au 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 également. Pensez à 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 et possède rooms
        }
    }
}

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. Considérons 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 : en composition, le conteneur crée ses parties en interne. En agrégation, les objets sont transmis depuis l’extérieur. Lorsqu’une Team est supprimée, les objets Player existent toujours. Lorsqu’une House est supprimée, ses objets Room disparaissent également.

Défi

Facile

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

Vous organiserez votre code sur quatre fichiers :

Professor.java : créez une classe représentant un professeur qui peut exister indépendamment de tout cours. Un Professor possède deux champs privés : name (String) et department (String). Ajoutez un constructeur pour initialiser les deux champs ainsi que des méthodes getter pour chacun d’eux. Redéfinissez toString() pour qu’elle renvoie : Prof. [name] ([department])
Lecture.java : créez une classe représentant une séance de cours qui n’a de sens qu’au sein d’un cours. Une Lecture possède deux champs privés : topic (String) et durationMinutes (int). Ajoutez un constructeur et des getters. Redéfinissez toString() pour qu’elle renvoie : Lecture: [topic] ([durationMinutes] min)
Course.java : c’est ici que vous démontrerez les deux relations ! Un Course possède trois champs privés : title (String), professor (Professor - agrégation) et lectures (un tableau d’objets Lecture - composition).
Le constructeur reçoit le titre du cours, un objet Professor (transmis depuis l’extérieur - agrégation) et le nombre de séances. Dans le constructeur, créez le tableau de Lecture et remplissez-le avec de nouveaux objets Lecture. Pour chaque séance à l’index i, créez-la avec le sujet "Topic " + (i + 1) et une durée de 45 minutes. Cette création interne démontre la composition.

Ajoutez une méthode getInfo() qui renvoie une String sur plusieurs lignes :
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Ajoutez également une méthode listLectures() qui renvoie une String contenant le résultat de toString() de chaque séance sur sa propre ligne.
Main.java : assemblez tous les éléments ! Vous recevrez quatre entrées : le nom du professeur (String), le département du professeur (String), le titre du cours (String) et le nombre de séances (int).
Commencez par créer un Professor avec le nom et le département fournis. Ce professeur existe indépendamment. Créez ensuite un Course en transmettant le titre, le professeur (agrégation) et le nombre de séances (le cours créera lui-même ses séances en interne - composition).

Affichez le résultat de getInfo(), puis affichez une ligne vide, puis affichez le résultat de listLectures().

Vous recevrez quatre entrées dans l’ordre suivant : nom du professeur, département, titre du cours et nombre de séances.

Remarquez la différence essentielle : le Professor est créé à l’extérieur puis transmis au Course (agrégation : le professeur pourrait enseigner d’autres cours ou exister sans celui-ci). Les Lectures sont créées dans le constructeur de Course (composition. Elles 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 entrées
        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 passant le professor (agrégation)
        // Le course créera ses propres lectures en interne (composition)
        
        // TODO: Afficher le résultat de getInfo()
        
        // TODO: Afficher une ligne vide
        
        // TODO: Afficher le résultat de listLectures()
        
    }
}