feat: add Java 25 features including simplified main method and flexible constructor bodies

Author: fpluquet

docs/cours/java/2-quelques-classes-utiles.md

@@ -44,3 +44,94 @@ Lire ce que l’utilisateur saisit, c’est le rôle de la classe `Scanner` (du
   ```
 
 Grâce à ces classes, vous disposez déjà d’un arsenal pour interagir avec le monde extérieur. Prêt à écrire vos premiers programmes dynamiques ?
+## Nouveauté Java 25 : la classe `IO`
+
+::: tip Java 25
+Depuis Java 25, une nouvelle classe `java.lang.IO` simplifie considérablement les entrées/sorties console. Comme elle fait partie du package `java.lang`, elle est disponible sans aucun import dans tous vos programmes.
+:::
+
+La classe `IO` propose cinq méthodes statiques pour les opérations de base :
+
+```java
+// Afficher du texte (équivalent de System.out.println)
+IO.println("Hello, World!");
+IO.print("Texte sans retour à la ligne");
+IO.println(); // Ligne vide
+
+// Lire une saisie utilisateur (équivalent de Scanner)
+String nom = IO.readln("Entrez votre nom : ");
+String ligne = IO.readln(); // Sans message d'invite
+```
+
+### Comparaison avec l'approche classique
+
+```java
+// Avant Java 25 : affichage + lecture
+import java.util.Scanner;
+
+public class Demo {
+    public static void main(String[] args) {
+        System.out.println("Hello, World!");
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Entrez votre nom : ");
+        String nom = scanner.next();
+        System.out.println("Bonjour " + nom);
+        scanner.close();
+    }
+}
+
+// Depuis Java 25 : même programme, simplifié
+void main() {
+    IO.println("Hello, World!");
+    String nom = IO.readln("Entrez votre nom : ");
+    IO.println("Bonjour " + nom);
+}
+```
+
+::: info
+La classe `IO` ne remplace pas `System.out` ni `Scanner` : ces classes restent disponibles et nécessaires pour des cas plus complexes (lecture de nombres, flux de fichiers, etc.). `IO` est conçue pour simplifier les cas d'usage les plus courants, notamment pour les débutants.
+:::
+
+## Nouveauté Java 25 : les imports de modules (`import module`)
+
+::: tip Java 25
+Depuis Java 25, il est possible d'importer d'un coup toutes les classes publiques exportées par un module, grâce à la syntaxe `import module`.
+:::
+
+Plutôt que d'écrire de multiples imports, on peut écrire une seule ligne :
+
+```java
+// Avant Java 25 : imports classiques
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+// Depuis Java 25 : un seul import de module
+import module java.base;
+```
+
+L'instruction `import module java.base;` rend disponibles toutes les classes de `java.util`, `java.io`, `java.math`, `java.time`, `java.util.stream`, etc. — soit les 54 packages exportés par le module `java.base`.
+
+::: info
+Dans un fichier source compact (sans déclaration de classe), `import module java.base;` est automatiquement présent. Vous n'avez même pas besoin de l'écrire !
+:::
+
+```java
+// Exemple avec import module
+import module java.base;
+
+class Demo {
+    void main() {
+        var noms = List.of("Alice", "Bob", "Charlie");
+        var majuscules = noms.stream()
+            .map(String::toUpperCase)
+            .collect(Collectors.toList());
+        IO.println(majuscules);
+    }
+}
+```
+
+::: warning Attention
+Si deux modules exportent des classes avec le même nom (ex : `java.util.List` et `java.awt.List`), il faudra résoudre l'ambiguïté avec un import spécifique classique.
+:::

docs/cours/java/3-methode-main.md

@@ -43,3 +43,69 @@ Argument 2 : test
 ```
 
 Ainsi, la méthode `main` est la porte d’entrée universelle de vos aventures Java. C’est ici que tout commence !
+## Nouveauté Java 25 : simplification de la méthode `main`
+
+::: tip Java 25
+Depuis Java 25, la signature de la méthode `main` a été considérablement simplifiée. Cette évolution vise à rendre le langage plus accessible aux débutants, en supprimant les éléments « cérémoniels » inutiles pour les petits programmes.
+:::
+
+### Instance `main` methods
+
+Les mots-clés `public`, `static` et le paramètre `String[] args` ne sont plus obligatoires. Java 25 permet d'écrire une méthode `main` d'instance, sans paramètre :
+
+```java
+// Avant Java 25 (toujours valide)
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello, World!");
+    }
+}
+
+// Depuis Java 25 : signature simplifiée
+class HelloWorld {
+    void main() {
+        System.out.println("Hello, World!");
+    }
+}
+```
+
+Le lanceur Java choisit la méthode `main` selon cette priorité :
+1. S'il existe une méthode `main(String[] args)` (statique ou non), elle est choisie.
+2. Sinon, s'il existe une méthode `main()` sans paramètre, elle est choisie.
+3. Si la méthode choisie n'est pas `static`, Java instancie la classe (qui doit avoir un constructeur sans argument) puis appelle `main()` sur l'objet créé.
+
+::: info
+La version classique `public static void main(String[] args)` reste parfaitement valide. La nouvelle syntaxe est simplement une alternative plus concise, idéale pour les petits programmes et l'apprentissage.
+:::
+
+### Compact Source Files (fichiers sources compacts)
+
+Java 25 va encore plus loin : il est possible d'écrire un programme sans même déclarer de classe ! On écrit directement les méthodes et champs dans le fichier source. Le compilateur crée automatiquement une classe implicite.
+
+```java
+// Fichier HelloWorld.java — pas de déclaration de classe !
+void main() {
+    System.out.println("Hello, World!");
+}
+```
+
+On peut même y déclarer des méthodes auxiliaires et des champs :
+
+```java
+// Fichier Greeting.java
+String greeting() { return "Hello, World!"; }
+
+void main() {
+    System.out.println(greeting());
+}
+```
+
+::: warning Attention
+Un fichier source compact doit obligatoirement contenir une méthode `main` exécutable. La classe implicite créée par le compilateur n'a pas de nom utilisable dans le code source (on ne peut pas l'instancier avec `new`).
+:::
+
+::: info Imports automatiques
+Dans un fichier source compact, toutes les classes publiques du module `java.base` sont automatiquement importées (comme si `import module java.base;` était présent en haut du fichier). Cela inclut `java.util.List`, `java.io.File`, `java.util.stream.Stream`, etc.
+:::
+
+Cette approche progressive (compact → classe explicite → projet structuré) permet aux débutants de se concentrer sur la logique avant de découvrir les concepts d'encapsulation et de modularité.

docs/cours/java/8-classes.md

@@ -64,7 +64,7 @@ Si vous ne définissez pas de constructeur, Java en crée un par défaut (sans a
 
 Parfois, on souhaite proposer plusieurs façons de créer un objet, avec plus ou moins d’informations. Pour éviter de répéter du code, on peut faire appel à la délégation de constructeurs : un constructeur peut en appeler un autre de la même classe, en passant des valeurs par défaut.
 
-**Attention : l’appel à un autre constructeur (`this(...)`) doit toujours être la première instruction du constructeur.**
+**Attention (avant Java 25) : l'appel à un autre constructeur (`this(...)`) doit toujours être la première instruction du constructeur.** _(Voir la section [Nouveauté Java 25](#nouveauté-java-25--corps-de-constructeurs-flexibles-flexible-constructor-bodies) pour l'évolution de cette règle.)_
 
 Exemple :
 
@@ -93,7 +93,62 @@ public class Personne{
 ::: tip Pourquoi déléguer ?
 Cela permet d’éviter la duplication de code et de centraliser la logique d’initialisation.
 :::
+### Nouveauté Java 25 : corps de constructeurs flexibles (Flexible Constructor Bodies)
 
+Avant Java 25, l'appel à `this(...)` ou `super(...)` **devait obligatoirement** être la première instruction d'un constructeur. Cela empêchait toute validation ou transformation des arguments avant la délégation.
+
+**Problème avant Java 25 :**
+
+```java
+public class Personne {
+    private String nom;
+
+    public Personne(String nom) {
+        // ❌ Impossible de valider `nom` avant d'appeler this(...) ou super(...)
+        // if (nom == null) throw new IllegalArgumentException("Le nom ne peut pas être null");
+        this.nom = nom;
+    }
+}
+```
+
+Avec Java 25 (JEP 513), on peut désormais écrire du code **avant** l'appel à `this(...)` ou `super(...)`, dans ce qu'on appelle le **prologue** du constructeur :
+
+```java
+public class Personne {
+    private String nom;
+    private String prenom;
+
+    public Personne(String nom) {
+        // ✅ Java 25 : on peut valider et transformer AVANT la délégation
+        if (nom == null) {
+            throw new IllegalArgumentException("Le nom ne peut pas être null");
+        }
+        String nomMajuscule = nom.toUpperCase();
+        this(nomMajuscule, "Inconnu"); // délégation après le prologue
+    }
+
+    public Personne(String nom, String prenom) {
+        this.nom = nom;
+        this.prenom = prenom;
+    }
+}
+```
+
+::: warning Restrictions dans le prologue
+Dans le prologue (avant `this(...)` ou `super(...)`), vous **ne pouvez pas** :
+- accéder à `this` (ni lire ni écrire les champs de l'instance en cours de construction)
+- appeler des méthodes d'instance
+
+Vous pouvez uniquement travailler avec les paramètres du constructeur et des variables locales.
+:::
+
+::: tip Comparaison
+| | Avant Java 25 | Java 25+ |
+|---|---|---|
+| Code avant `this(...)` / `super(...)` | ❌ Interdit | ✅ Autorisé (prologue) |
+| Validation des arguments | Après la délégation uniquement | Avant la délégation |
+| Accès à `this` dans le prologue | — | ❌ Interdit |
+:::
 ## Redéfinition (surcharge) de constructeur
 
 Il est possible de définir plusieurs constructeurs dans une même classe, à condition qu’ils aient des signatures différentes (nombre ou type des arguments). C’est ce qu’on appelle la **surcharge**.