Leçons

Nous expliquons pas à pas comment Java initialise un objet : valeurs par défaut des champs, initialisation explicite, blocs d’initialisation d’instance et appel final du constructeur via new. À l’exemple de la classe Person, nous verrons l’ordre effectif d’affichage, un tableau des valeurs par défaut, un organigramme et des erreurs typiques (duplication de logique, attentes concernant static, gestion de null, appel d’un constructeur via this(...)).

Comment trouver une erreur sans devenir fou. Apprenons à utiliser le Debugger : points d'arrêt (breakpoints), exécution pas à pas, inspection des variables et évaluation d'expressions à la volée.

Dans cette leçon, nous verrons ce qu’est l’encapsulation en Java, comment elle est réalisée à l’aide de champs privés ( private) et d’une interface publique (méthodes public), pourquoi il faut masquer l’état interne des objets et en quoi cela améliore la fiabilité et la maintenabilité du code. Vous verrez de mauvais et de bons exemples, des applications pratiques, un tableau comparatif des approches et des erreurs typiques.

Dans cette leçon, nous passons en revue les niveaux d’accès en Java : public, protected, package-private et private. Nous verrons où et pourquoi utiliser chacun d’eux, comment protéger les champs (encapsulation), quelles règles choisir pour les méthodes et les constructeurs, des exemples avec les packages et l’héritage, ainsi que les meilleures pratiques et les erreurs typiques.

Dans cette leçon, vous verrez comment, grâce à l’encapsulation et aux méthodes get/ set, contrôler l’accès aux champs d’une classe en Java. Vous découvrirez les conventions JavaBeans, la spécificité des champs de type boolean avec des getters isXxx(), verrez des exemples de validation dans les setters, de manipulation sûre des champs mutables et de génération automatique des accesseurs dans les IDE.

Dans ce cours, vous verrez comment initialiser les champs statiques ( static) et les champs immuables ( final) en Java : lors de la déclaration, dans un bloc d’initialisation statique, ainsi que dans les constructeurs. Nous parlerons du trio de constantes public static final, de l’accès correct aux éléments statiques, de l’ordre d’initialisation et des erreurs courantes à éviter.

Dans cette leçon, vous allez comprendre les blocs d’initialisation en Java : en quoi les blocs non statiques et static-blocs diffèrent, dans quel ordre s’exécutent les champs, les blocs et les constructeurs, quand il est pertinent d’extraire une logique commune dans des blocs, et quand il vaut mieux utiliser des constructeurs. Nous examinerons des exemples, les subtilités de l’héritage et les erreurs typiques.

Passons en revue les classes internes (non-static inner) en Java : ce que c’est et comment elles sont liées à l’instance de la classe externe, comment les déclarer et les créer via outer. new Inner(), comment elles accèdent aux membres avec les modificateurs private/ public, quelles limitations existent (aucun membre static à part les constantes), ainsi que les options de visibilité et des exemples pratiques : Backpack.Item, l’itérateur de sa propre collection et la référence à l’objet externe via OuterClassName. this. Pour finir — les erreurs typiques et comment les éviter.

Nous expliquons les classes imbriquées statiques en Java : ce que c’est, en quoi elles diffèrent des classes internes (inner), comment les déclarer avec le modificateur static, comment créer des instances sans objet de la classe externe, et quelles règles d’accès s’appliquent (pas de OuterClass.this, accès uniquement aux membres statiques). Nous montrerons des scénarios pratiques — Builder, nœuds internes Node dans des structures, utilitaires —, nous les comparerons aux classes internes, ajouterons un diagramme et analyserons les erreurs typiques : confusion avec outer.new Inner() et l’appel correct new Outer.Nested().

Dans ce cours, nous abordons les classes anonymes en Java : ce que c’est, comment elles sont déclarées et instanciées à l’endroit où elles sont utilisées, comment le compilateur nomme leurs fichiers .class, les contraintes (final/effectively final, absence de constructeur, blocs d’initialisation) et des scénarios pratiques d’utilisation. Nous montrerons l’accès aux membres de la classe englobante et analyserons les erreurs typiques.

Nous explorons les classes locales en Java : de quoi il s’agit, comment les déclarer à l’intérieur des méthodes et des blocs, quelles sont les restrictions sur les modificateurs et les membres statiques, et comment fonctionne l’accès aux variables de la méthode (seulement final/ effectively final). Nous les comparerons aux classes anonymes, verrons des exemples pratiques (comparateur, structure de données temporaire, mini‑résultat de test) et les erreurs typiques. Vous comprendrez quand une classe locale est plus appropriée qu’une anonyme et pourquoi il faut garder en tête static et public/ private/ protected.

Introduction pratique aux génériques (Generics) en Java : pourquoi stocker dans Object est risqué, comment déclarer des classes et des méthodes génériques, comment utiliser Box<T>, des paires et des méthodes universelles, et quels avantages apporte la sécurité de type sans conversions explicites. Nous aborderons les limitations (types primitifs, effacement des types) et passerons en revue des exemples d’utilisation.