# 🟧 1. Méthodes : outil central de la structuration du code
Les méthodes permettent d’organiser un programme en unités cohérentes.
Elles ont quatre dimensions essentielles :
- **leur visibilité**,
- **leurs paramètres**,
- **leur valeur de retour**,
- **leur surcharge** (plusieurs versions d’une même méthode).
## ✔ Visibilité des méthodes
```java
public void demarrer() { ... } // accessible partout
private void calculer() { ... } // accessible uniquement dans la classe
```
- `public` → méthode accessible depuis l'extérieur
- `private` → méthode interne, utilisée pour factoriser le code
## ✔ Paramètres d'une méthode
Un paramètre permet de transmettre une information à la méthode :
```java
public void augmenterDe(int delta) {
vitesse += delta;
}
```
Tous les paramètres en Java sont transmis **par copie de la valeur**, même les objets (on copie la référence, pas l’objet).
## ✔ Valeur de retour
Une méthode peut renvoyer un résultat :
```java
public int getVitesse() {
return vitesse;
}
```
Si aucune valeur n'est renvoyée, le type est `void`.
## ✔ Surcharge
Plusieurs méthodes peuvent partager le même nom tant que **leur liste de paramètres diffère** :
```java
public void setPosition(int x) { ... }
public void setPosition(int x, int y) { ... }
```
Cela améliore la lisibilité et l’intuitivité du code.
## ✔ Portée des variables
```java
void methode() {
int x = 10; // variable locale à la méthode
if(x > 0) {
int y = 20; // portée limitée au bloc
}
}
```
Une variable locale disparaît dès la fin du bloc qui la contient.
# 🟦 2. Les attributs et méthodes `static`
Un élément `static` appartient **à la classe**, pas aux objets.
```java
public class Compteur {
public static int total = 0;
}
```
On y accède sans créer d'instance :
```java
System.out.println(Compteur.total);
```
### ✔ Méthodes static
Elles sont utiles pour les fonctions indépendantes du contexte des objets :
```java
public static double carre(double x) {
return x * x;
}
```
# 🟩 3. Les classes utilitaires
Java propose des classes « outils » souvent composées de méthodes `static`.
Exemples fréquents :
- `Math` — fonctions mathématiques (`sqrt`, `pow`, `random`)
- `Arrays` — manipulation de tableaux
- `Collections` — utilitaires pour les collections
```java
double r = Math.sqrt(25);
int[] t = {3, 1, 2};
Arrays.sort(t);
```
Ces classes sont essentielles pour éviter de réinventer des outils déjà existants.
# 🟪 4. Les énumérations (`enum`)
Les énumérations permettent de définir un ensemble **fermé** de valeurs possibles.
```java
public enum Direction {
HAUT, BAS, GAUCHE, DROITE
}
```
Utilisation :
```java
Direction d = Direction.GAUCHE;
```
Elles améliorent la **sécurité**, la **lisibilité** et la **robustesse** du code.
# 🟫 5. Tableaux en Java
## ✔ Déclaration
```java
int[] notes;
```
## ✔ Construction
```java
notes = new int[5];
```
## ✔ Initialisation rapide
```java
int[] notes = {12, 14, 9, 18};
```
## ✔ Accès
```java
int x = notes[2]; // 3e élément
notes[1] = 20;
```
## ✔ Tableaux multidimensionnels
```java
int[][] grille = new int[3][3];
grille[0][2] = 5;
```
Utile pour représenter des environnements comme dans Wa‑Tor.
# 🟦 6. Les chaînes de caractères (`String`)
Les chaînes sont **immutables** : une fois créées, elles ne changent pas.
```java
String s = "Java";
s = s + " 42"; // crée une nouvelle chaîne
```
## ✔ Méthodes utiles
```java
s.length();
s.charAt(0);
s.substring(2);
s.equals("test");
```
### ⚠ Ne jamais comparer les chaînes avec `==`
Toujours utiliser `.equals()`.
# 🟧 7. Exceptions : gérer les erreurs proprement
Les exceptions permettent de gérer les erreurs **sans arrêter brutalement** le programme.
## ✔ Bloc `try` / `catch`
```java
try {
int x = 10 / 0;
}
catch (ArithmeticException e) {
System.out.println("Division impossible !");
}
```
## ✔ `throw` : lancer une exception
```java
if(vitesse < 0)
throw new IllegalArgumentException("Vitesse incorrecte");
```
## ✔ Propagation
Une méthode peut signaler qu’elle transmet l’exception à l’appelant :
```java
public void f() throws IOException {
// ...
}
```
# 🟫 8. Packages et organisation du code
Les packages permettent de **structurer** un projet Java.
```java
package modele;
```
Pour utiliser une classe située ailleurs :
```java
import outils.MathUtils;
```
### ✔ Règle :
- 1 package = 1 dossier
- 1 classe = 1 fichier
C’est indispensable pour les projets Java de taille moyenne ou grande.
# 🗓️ Historique
> Dernière mise à jour : 22 novembre 2025
> Rédigé par : [[Julien DUQUENNOY]]