# 🟧 1. Tableaux d’objets
Un tableau peut contenir **n’importe quel type d’objet**.
Il permet de regrouper plusieurs instances, mais sa taille reste **fixe**.
## âś” DĂ©claration
```java
Voiture[] garage;
```
## âś” Construction
```java
garage = new Voiture[3];
```
Le tableau contient 3 cases… mais toutes valent **null** tant qu’on n’a pas créé les objets.
## âś” Initialisation
```java
garage[0] = new Voiture("Renault");
garage[1] = new Voiture("Peugeot");
garage[2] = new Voiture("Tesla");
```
## ✔ Parcours d’un tableau
```java
for (int i = 0; i < garage.length; i++) {
garage[i].demarrer();
}
```
Les tableaux sont utiles lorsque :
- le nombre d’éléments est connu à l’avance,
- la structure est stable (ex. : grille Wa‑Tor, plateau de jeu).
# 🟦 2. Listes d’objets (`ArrayList`)
Contrairement aux tableaux, une liste peut **changer de taille**.
```java
import java.util.ArrayList;
ArrayList<Voiture> garage = new ArrayList<>();
```
## âś” Ajouter des objets
```java
garage.add(new Voiture("Renault"));
garage.add(new Voiture("Peugeot"));
```
## ✔ Accéder aux éléments
```java
Voiture v = garage.get(0);
```
### đź“ť Pourquoi utiliser des listes ?
- Adaptées aux environnements dynamiques
- Gestion simplifiée des insertions / suppressions.
# đźź© 3. Composition
La **composition** modélise une relation *forte* : l’objet contenu **n’existe pas sans** l’objet qui le possède.
Exemple : une voiture possède un châssis.
```java
public class Chassis {
private int numero;
}
```
```java
public class Voiture {
private Chassis chassis;
public Voiture() {
chassis = new Chassis();
}
}
```
### 📝 Caractéristiques
- lien indissociable : la destruction de la voiture entraîne celle du châssis
- le châssis n'a pas d'existence en dehors de la voiture
# 🟪 4. Agrégation
L’agrégation représente une relation *faible* : l’objet contenu peut exister **indépendamment**.
Exemple : une voiture possède des roues interchangeables.
```java
public class Roue {
}
```
```java
public class Voiture {
private Roue[] roues;
}
```
### 📝 Caractéristiques
- la roue peut exister en dehors de la voiture
- une roue peut être associée à plusieurs voitures
# 🟫 5. Classe‑association
Une association entre deux classes peut porter des informations. On utilise alors une **classe‑association**.
Exemple : une personne possède une voiture avec une **date d’achat**.
```java
public class Possession {
private Personne proprietaire;
private Voiture voiture;
private String dateAchat;
}
```
# 🟦 6. Héritage
L’héritage permet de créer une classe **spécialisée** à partir d’une classe générale.
```java
public class Poisson {
protected int age;
public void vieillir() {
age++;
}
}
```
```java
public class Thon extends Poisson {
public void nagerVite() {
}
}
```
```java
public class Requin extends Poisson {
public void chasser() {
}
}
```
### 📝 Intérêt
- réutilisation de code
- spécialisation propre
# 🟨 7. Le mot-clé `super`
Le mot-clé `super` est utilisé dans les classes filles pour **accéder explicitement aux éléments de la super-classe**.
Il est indispensable pour bien contrôler l’héritage.
## ✔ 1. Appeler le constructeur de la classe mère
Lorsque la super-classe possède un constructeur avec paramètres, la classe fille doit l’appeler :
```java
public class Poisson {
protected int age;
public Poisson(int ageInitial) {
age = ageInitial;
}
}
```
```java
public class Thon extends Poisson {
public Thon(int ageInitial) {
super(ageInitial); // appel du constructeur parent ou super-constructeur
}
}
```
### 📌 Pourquoi l’utiliser ?
- pour initialiser correctement la partie “commune” de l’objet
- pour Ă©viter la duplication de code
- pour garantir la cohérence entre classes parentes et filles
## ✔ 2. Appeler une méthode de la super-classe
Si une méthode est redéfinie (override), on peut appeler la version parent :
```java
@Override
public void vieillir() {
super.vieillir(); // appelle la méthode de Poisson
// puis spécialisation
energie -= 1;
}
```
### đź“Ś Utile pour :
- enrichir un comportement existant
- conserver une partie du fonctionnement de la super-classe
## ✔ 3. Accéder à un attribut protégé (`protected`)
`protected` permet l’accès direct dans les classes filles, contrairement à `private`.
```java
public class Requin extends Poisson {
public void chasser() {
if (age > 5) {
// accès direct à age car il est protected
}
}
}
```
📌 Les attributs doivent rester `private` sauf justification pédagogique.
`protected` est acceptable **uniquement dans les hiérarchies d’héritage claires**.
## 📝 À retenir
- `super()` → appelle un constructeur parent
- `super.methode()` → appelle une méthode parent
- accès possible aux attributs `protected`
# 🟧 8. Polymorphisme
Une variable de type **classe mère** peut contenir un objet de type **classe fille**.
```java
Poisson[] population = new Poisson[3];
population[0] = new Thon();
population[1] = new Requin();
population[2] = new Thon();
```
Lors d’un appel :
```java
population[i].vieillir();
```
La **version adaptée** à l’objet réel est exécutée.
### 📝 Pourquoi est‑ce indispensable ?
- listes hétérogènes (thons + requins dans la même collection)
- simplification massive du code
# 🗓️ Historique
> Dernière mise à jour : 22 novembre 2025
> Rédigé par : [[Julien DUQUENNOY]]