#Programmation orientée objet en JavaCopier le lien

Java reste un pilier de l'industrie logicielle : la machine virtuelle exécute le même bytecode partout, l'outillage est mature et le langage évolue à rythme semestriel (records, pattern matching, virtual threads). Ce module revisite la programmation orientée objet avec un regard moderne : expliciter les invariants, maîtriser l'encapsulation, choisir entre héritage et composition, puis exploiter les apports récents du langage pour écrire du code court et vérifiable.

Prérequis

• Bases d'un premier langage (variables, conditions, boucles, fonctions) : le parcours prog-python suffit.
• Notions de types et de structures de données élémentaires (listes, tables associatives).
• Un environnement Java 21+ installé (JDK) pour exécuter les exemples.

Objectifs d'apprentissage

• Modéliser un domaine avec des classes qui protègent leurs invariants.
• Décider consciemment entre héritage, interfaces et composition.
• Stabiliser des API avec la généricité, les records et les interfaces scellées.
• Traiter des collections et des flux de données avec l'API Stream et la concurrence moderne.
• Fiabiliser un projet : exceptions, tests, observabilité, build et livraison.

#Fil conducteur : une petite banqueCopier le lien

Tout le module s'appuie sur un même exemple fil rouge, la gestion de comptes bancaires et de virements. Ce domaine est assez riche pour lever les vraies questions de conception : quelles données sont immuables ? Quelles opérations sont atomiques ? Quelles erreurs appartiennent au métier, lesquelles signalent un bug ? Chaque chapitre fait grandir ce modèle plutôt que d'introduire un exemple nouveau, afin que les décisions se comparent entre elles.

#Plan du moduleCopier le lien

1. Modélisation objet : invariants, encapsulation, records pour les valeurs immuables.
2. Héritage et composition : quand extends est justifié, sinon comment composer des comportements via interfaces et délégation ; patrons State, Strategy, Template Method revisités.
3. Interfaces, génériques et records : variance (PECS), interfaces scellées, pattern matching et switch exhaustifs.
4. Collections et Streams : choisir les bonnes structures, composer des transformations paresseuses, paralléliser à bon escient, virtual threads et concurrence structurée.
5. Qualité et tests : hiérarchie d'exceptions, pyramide de tests JUnit 5 et AssertJ, mutation testing, logs et métriques.
6. Outillage et écosystème : Maven ou Gradle, IDE, analyse statique, packaging jlink/jpackage, intégration continue.

#MéthodeCopier le lien

Chaque chapitre alterne explications, code complet commenté et ateliers guidés dont vous pouvez vérifier le résultat (sortie console attendue ou test qui passe). Les projets de synthèse en fin de parcours (micro-service REST, pipeline d'événements, traitement de logs concurrents) réutilisent l'ensemble des briques sur le même fil conducteur.