Leçons

Nous passons en revue les interfaces clés de la bibliothèque standard Java et pourquoi elles sont utiles dans des projets réels : tri « naturel » via Comparable<T> et règles personnalisées avec Comparator<T>, sérialisation des objets avec Serializable, gestion sûre des ressources via AutoCloseable, itération des collections grâce à Iterable<T>, ainsi que les interfaces marqueurs Cloneable et les écouteurs d’événements. À travers des exemples riches, nous verrons les signatures correctes des méthodes ( compareTo, compare, close, iterator) et les erreurs typiques à éviter.

Nous abordons les classes record dans Java 16+ : comment les déclarer, ce que le compilateur génère « sous le capot », en quoi elles sont plus pratiques que les DTO classiques et les objets valeur, et quand les utiliser. Moins de code passe-partout, plus de sécurité : immuabilité, equals/hashCode/toString corrects et facilité d’utilisation dans les collections.

Plongeons dans l’immutabilité (immutability) des classes record en Java : pourquoi leur état ne peut pas être modifié après la création, quels avantages cela apporte en environnement multithread et lors du travail avec les collections, en quoi les records diffèrent des classes ordinaires, et comment se protéger correctement contre les « fuites de mutabilité » via les tableaux et les collections. Nous comparerons le comportement avec des classes mutables, analyserons des exemples pratiques et les erreurs typiques.

Examinons pourquoi les objets ont besoin des méthodes equals, hashCode et toString, pourquoi leur implémentation manuelle dans les classes ordinaires conduit à du code répétitif et sujet aux erreurs, et comment les classes record génèrent automatiquement des versions correctes. Nous verrons l’impact sur les collections et le débogage, quand et comment il est pertinent de redéfinir le comportement standard, ainsi que les erreurs les plus fréquentes.

Apprenons à enrichir les classes record avec des méthodes, à utiliser des constructeurs compacts pour valider et normaliser les données, à examiner les limitations des record, l’implémentation d’interfaces et des techniques pratiques. À la fin — un tableau « ce qui est possible/interdit » et un passage en revue des erreurs typiques.

Principales différences entre les classes ordinaires et les classes record en Java : immutabilité, héritage, génération automatique de equals/hashCode/toString, constructeurs et cas d’usage. Nous examinerons les restrictions des records, où ils apportent le plus de valeur (DTO, Value Object, clés de collections), quand il est préférable d’utiliser une classe classique, et les erreurs les plus fréquentes.

Erreurs fréquentes au démarrage en Java : modificateurs d’accès des classes, concordance entre le nom du fichier et celui de la classe public, accolades et placement des membres de classe, initialisation des objets, constructeurs et créations d’instances superflues. Nous examinerons les bonnes pratiques et réaliserons un mini‑exemple « Bibliothèque », puis nous analyserons à la fin les messages d’erreur typiques.

Analysons les erreurs fréquentes en Java lors de l’héritage et de la surcharge de méthodes : appel du constructeur de la classe de base via super(...), contraintes des classes et méthodes marquées final, violation du principe de substitution de Liskov, pièges de la surcharge (autopromotion des types, appels ambigus, tentative de différencier uniquement par le type de retour), ainsi que les meilleures pratiques et des exemples opérationnels avec le polymorphisme.

Nous détaillons pas à pas les niveaux d'accès en Java et les erreurs courantes : modificateurs oubliés, violation de l'encapsulation, particularités de protected en dehors du package, usage correct des getters/setters et retour de copies des collections. Nous consolidons les bonnes pratiques au moyen d'exemples pratiques.

Nous examinons le polymorphisme et les abstractions en Java en pratique : comment une interface unique déclenche des comportements différents, les erreurs fréquentes (downcasting sans vérification, appel de méthodes absentes du type de base, abstractions « vides », hiérarchies profondes), ainsi que les meilleures pratiques d’utilisation des classes abstraites, des interfaces et de l’annotation @Override dans l’exemple pédagogique « Bibliothèque ».

Pourquoi les développeurs Java ont besoin d’un style de code unifié et comment s’y tenir : nous passerons en revue les erreurs de mise en forme typiques, les conventions de base (indentation, nommage, ordre des membres de classe), nous montrerons des exemples de refactorisation ainsi que des outils de formatage automatique et d’analyse statique, afin que le code soit lisible et maintenable.

Dans cette leçon, nous abordons les bases du système d’exceptions de Java : la classe racine Throwable, les différences entre Exception et Error, ainsi que la distinction entre exceptions vérifiées et non vérifiées. Vous verrez un diagramme et un tableau des différences, des exemples de code avec try- catch et throws, apprendrez quoi intercepter et quoi — pas, et passerez en revue les erreurs typiques lors du traitement des exceptions.