Leçons

Nous expliquons ce qu’est le fichier module-info.java, où il se trouve dans le projet et comment déclarer un module à l’aide du mot-clé module. Nous apprenons à exporter une API via exports, à déclarer des dépendances via requires, et nous examinons aussi des directives supplémentaires ( opens, uses, provides ... with). Dans ce cours — exemples, règles de nommage des modules, analyse pratique de la structure du projet et erreurs typiques lors de l’assemblage modulaire.

Comment Java 9+ a ajouté une encapsulation modulaire par-dessus les classes et les packages : même les classes public sont cachées tant que le package n’est pas explicitement ouvert via exports dans module-info.java. Nous expliquons comment déclarer des dépendances avec requires, comment limiter la visibilité avec exports to, en quoi le niveau module diffère de private/ public, et quels messages d’erreur de compilation (par exemple, « package ... is not visible », « cannot access ... ») indiquent que vous avez oublié exports ou requires.

Guide pratique de l’architecture modulaire en Java : quand et pourquoi découper le code en modules, schémas types (architecture « en oignon », séparation en api/ impl, modules de tests), configuration des dépendances via module-info.java et les mots-clés requires/ exports, exemples concrets d’un projet à 3 modules, intégration avec Maven/ Gradle et IntelliJ IDEA, ainsi qu’une analyse des erreurs courantes (dépendances circulaires, packages non exportés, --module-path incorrect).

Comment assembler un projet modulaire en Java: différence entre classpath et module-path, quand utiliser l’option --module-path, comment configurer une structure multi-modules avec Maven et Gradle, et comment tout lancer depuis IntelliJ IDEA. Nous montrerons la structure des modules avec module-info.java, les dépendances via requires/ exports, la configuration des plugins et les erreurs fréquentes lors de l’assemblage.

Voyons comment lancer des commandes et utilitaires externes depuis Java à l’aide de la classe ProcessBuilder : en quoi elle est préférable à Runtime. getRuntime(). exec(), comment configurer le répertoire de travail via directory(), les variables d’environnement via environment(), et piloter le processus via start(), waitFor(), les flux getInputStream()/ getErrorStream()/ getOutputStream(). Nous aborderons la multiplateforme ( cmd.exe/ ls), la gestion de stdout/ stderr et les erreurs courantes.

Pratique de la manipulation de processus externes en Java : comment lire stdout via Process.getInputStream(), capter les erreurs depuis stderr via Process.getErrorStream(), écrire sur stdin à l’aide de Process.getOutputStream(), ainsi qu’utiliser les méthodes pratiques inputReader()/ errorReader()/ outputWriter(). Nous examinerons les particularités de commandes comme java -version, la lecture parallèle des flux pour éviter un deadlock, la gestion des encodages ( "UTF-8") et un petit bridge avec des scripts Python.

Pratique de la gestion des processus externes depuis Java : attendre la fin via waitFor() (y compris avec des délais d’attente), lire le code de sortie, arrêter proprement via destroy()/ destroyForcibly(), éviter les blocages et les processus « zombies », sans oublier les flux de sortie et les exceptions. Nous passons en revue les nuances multiplateformes et les erreurs courantes.

Dans ce cours, nous verrons comment organiser depuis Java un dialogue « en direct » avec des programmes externes : écrire dans stdin, lire depuis stdout et stderr, éviter les blocages mutuels ( deadlock), traiter la sortie en parallèle via ExecutorService, fermer correctement les flux et gérer le cycle de vie d’un Process au moyen de ProcessBuilder. Nous regarderons des exemples avec un script interactif en Python et l’utilitaire bc, ainsi que les pièges de la mise en tampon et la nécessité d’appeler flush().

Guide pratique pour une utilisation fiable des processus externes en Java : comment éviter les blocages dus aux flux stdout/ stderr non lus, configurer correctement les encodages de sortie (par exemple, UTF-8, CP866), tenir compte des différences multiplateformes des commandes ( ls vs dir), traiter les droits d’accès et les codes de sortie via process.exitValue(), fermer les ressources sans fuites et éviter les interblocages interactifs. Nous abordons le bon usage de ProcessBuilder, la lecture parallèle des flux (threads/ ExecutorService), l’arrêt correct via process.destroy(), ainsi que des chemins portables avec File.separator.

Nous verrons ce qu’est la réflexion en Java et pourquoi elle est utile aux frameworks et aux outils, comment fonctionne l’objet Class — le cœur de la réflexion — et les différentes façons de l’obtenir : via .class, getClass() et Class.forName(). Nous discuterons quand utiliser la réflexion et quand il vaut mieux s’en passer, nous examinerons des exemples d’obtention de métadonnées (nom, package, superclasse, interfaces), nous passerons en revue un mini‑utilitaire « Quelle est cette classe ? » et les erreurs typiques ( ClassNotFoundException, performances, sécurité).

Dans ce cours, nous étudions la réflexion en Java : comment, via Class-API, obtenir des informations sur les champs ( getFields()/ getDeclaredFields()), les méthodes ( getMethods()/ getDeclaredMethods()), les constructeurs ( getConstructors()/ getDeclaredConstructors()) et les annotations ( getAnnotations()). Nous examinerons les modificateurs via Modifier ( public, private, protected, static, final), clarifierons les différences entre « public » et « declared », construirons un mini utilitaire d’inspection de classes et verrons un schéma visuel.

Dans ce cours, nous examinons les risques et les limites de la réflexion : contournement de l’encapsulation via setAccessible( true), tentatives de modifier des champs final et pourquoi c’est dangereux à cause des optimisations de la JVM ; le destin de SecurityManager et comment le système de modules (Java 9+) conduit à InaccessibleObjectException. Nous parlerons de perte de performances et de sécurité de typage, des alternatives modernes ( record, sealed, pattern matching, APT, DI) et des bonnes pratiques. Pour finir — un exemple pratique avec le paramètre JVM --add-opens.