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 du cycle de vie.

Dans la 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 les 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érez 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);  // L'équipe utilise des joueurs existants
    }
}

La distinction clé : dans la composition, le conteneur crée ses parties en interne. Dans l'agrégation, les objets sont transmis de 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), alors 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). Incluez un constructeur pour initialiser les deux champs et des méthodes getter pour chacun. Surchargez toString() pour retourner : "Prof. " + name + " (" + department + ")"
Lecture.java : Créez une classe représentant un cours magistral qui n'a de sens qu'au sein d'un cours. Une Lecture possède deux champs privés : topic (String) et durationMinutes (int). Incluez un constructeur et des getters. Surchargez toString() pour retourner : "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 prend le titre du cours, un objet Professor (passé de l'extérieur - agrégation), et le nombre de cours magistraux. À l'intérieur du constructeur, créez le tableau Lecture et remplissez-le avec de nouveaux objets Lecture. Pour chaque cours magistral à l'index i, créez-le 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 retourne une chaîne multi-ligne :
```
Course: [title]
Instructor: [professor.toString()]
Lectures: [number of lectures]
```
Ajoutez également une méthode listLectures() qui retourne une chaîne avec le toString() de chaque cours magistral sur sa propre ligne.
Main.java : Rassemblez tout ! 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 cours magistraux (int).
Tout d'abord, créez un Professor avec le nom et le département donnés — ce professeur existe indépendamment. Ensuite, créez un Course, en passant le titre, le professeur (agrégation), et le nombre de cours magistraux (le cours créera ses propres cours magistraux 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 : le nom du professeur, le département, le titre du cours, et le nombre de cours magistraux.

Notez la différence clé : le Professor est créé à l'extérieur et passé au Course (agrégation — le professeur pourrait enseigner d'autres cours ou exister sans celui-ci). Les Lectures sont créées à l'intérieur du constructeur Course (composition — elles appartiennent exclusivement à ce cours et n'existeraient pas sans lui).

Aide-mémoire

L'agrégation et la composition sont toutes deux des relations de type « has-a » (a un) qui diffèrent par la propriété et la dépendance du cycle de vie.

Composition : L'objet contenu ne peut pas exister indépendamment du conteneur. Lorsque le conteneur est détruit, ses parties le sont également. Le conteneur crée ses parties en interne.

class House {
    private Room[] rooms;
    
    public House(int numRooms) {
        rooms = new Room[numRooms];
        for (int i = 0; i < numRooms; i++) {
            rooms[i] = new Room();  // La maison crée et possède les pièces
        }
    }
}

Agrégation : L'objet contenu peut exister indépendamment. Le conteneur utilise l'objet mais ne contrôle pas son cycle de vie. Les objets sont transmis de l'extérieur.

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

Distinction clé : Lorsqu'un conteneur est supprimé, les objets agrégés existent toujours, mais les objets composés sont détruits.

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 professeur (agrégation)
        // Le cours créera ses propres cours magistraux en interne (composition)
        
        // TODO: Afficher le résultat de getInfo()
        
        // TODO: Afficher une ligne vide
        
        // TODO: Afficher le résultat de listLectures()
        
    }
}