Leçons

Dans cette leçon, nous verrons ce qu’est l’héritage en Java, comment il permet d’éviter la duplication de code, ainsi que la manière de déclarer des hiérarchies avec le mot-clé extends. Nous examinerons ce que la sous-classe hérite exactement, quelles sont les contraintes (héritage simple, membres privés, constructeurs), un exemple pratique avec des animaux, des nuances liées aux constructeurs et les erreurs typiques.

Dans ce cours, nous abordons la redéfinition de méthodes en Java : comment et pourquoi une sous-classe remplace le comportement de la classe parente, l’utilité de l’annotation @Override, comment fonctionne le polymorphisme lors des appels via une référence de type de base, ainsi que les règles clés (signature, modificateurs d’accès, exceptions, covariance) et les restrictions ( static, final, private). Nous terminons par de la pratique sur un mini‑projet « Zoo » et une revue des erreurs typiques.

Nous analysons le mot-clé super en Java : comment appeler les méthodes et les constructeurs de la classe de base, comment accéder aux champs du parent masqués, quand et pourquoi étendre le comportement via super et super(...), ainsi que les limitations (impossible à utiliser dans les méthodes statiques, pas d’accès au private) et les erreurs courantes. De nombreux exemples pratiques sur les hiérarchies Animal/ Cat/ Dog et Vehicle/ Car.

Nous allons apprendre à concevoir et à implémenter des hiérarchies de classes en Java : comment distinguer le général et le spécifique, construire un arbre d’héritage, quand la relation is-a est appropriée et quand il vaut mieux utiliser la composition ( has-a). Nous examinerons des exemples concrets (animaux, géométrie, transport, utilisateurs), des subtilités d’architecture et les erreurs typiques de conception.

Dans cette leçon, nous abordons les limites du modèle d’héritage en Java : héritage simple des classes, absence d’héritage des constructeurs et inaccessibilité des membres private. Nous analyserons les hiérarchies « fragiles » et l’effet d’un héritage « cassant », présenterons des alternatives — composition ( has-a), délégation et interfaces — ainsi que des critères pour savoir « quand il faut vraiment extends ». Au passage, nous noterons l’appel du constructeur parent via super(...) et les erreurs de conception typiques.

Dans cette leçon, nous abordons le polymorphisme en Java : ce que c’est, en quoi overloading et overriding diffèrent, comment fonctionne la liaison tardive et pourquoi une interface peut avoir de multiples implémentations. À l’aide d’exemples pratiques, nous verrons comment le polymorphisme simplifie l’architecture, rend le code extensible et réduit le couplage entre modules.

Plongeons dans la surcharge de méthodes en Java : quand il est pertinent de déclarer plusieurs versions d’une même méthode, comment le compilateur choisit la meilleure correspondance selon les paramètres, pourquoi on ne peut pas surcharger uniquement par le type de retour, et comment fonctionnent les constructeurs surchargés et ... varargs. Nous examinerons des exemples avec println, créerons un petit Calculator et passerons en revue les erreurs typiques liées à l’auto-conversion et aux ambiguïtés entre Integer/ Long.

Nous examinons en détail la redéfinition des méthodes en Java : comment l’overriding assure le polymorphisme à l’exécution, en quoi il diffère de overloading, quelles règles s’appliquent (signatures, accès, exceptions, covariance), comment utiliser @Override et appeler la logique du parent via super. Nous montrerons des exemples pratiques et analyserons les erreurs typiques.

Nous montrons le polymorphisme sur des exemples concrets : comment stocker des objets hétérogènes dans une seule collection du type de base et appeler les « bons » méthodes sans if/ switch, comment l’ajout d’une nouvelle sous-classe ne nécessite pas de réécrire la logique, et quelles sont les limites de l’approche. Nous construirons une hiérarchie d’employés avec la méthode work(), parlerons d’extensibilité et examinerons les erreurs typiques.

Comment les classes et méthodes abstraites définissent un contrat commun et permettent le polymorphisme en Java : pourquoi on ne peut pas instancier un objet abstrait, comment les sous-classes implémentent les méthodes obligatoires, comment travailler via le type de base tout en obtenant le « bon » comportement. Nous verrons des exemples avec des animaux et une hiérarchie d’employés, des subtilités de syntaxe et des erreurs courantes.

Une introduction claire à l’abstraction en POO avec Java : ce que c’est, pourquoi elle est utile et comment l’appliquer dans la conception. Nous passerons en revue les outils du langage — les classes abstraites abstract class et les interfaces interface, les méthodes abstraites et le travail via un contrat commun (par exemple, des appels comme payment.process() ou draw()). À l’aide d’exemples pratiques ( Shape, Payment, Transport), nous montrerons comment masquer les détails d’implémentation, réduire le couplage et faciliter l’extension du système.

Dans ce cours, nous passons en revue pas à pas les classes et méthodes abstraites en Java : quand utiliser abstract, comment déclarer une class abstraite, quelle est la différence avec un interface, et comment implémenter les méthodes obligatoires (par exemple, makeSound()) dans les sous-classes. Nous accompagnerons la théorie d’exemples parlants ( Animal, Transport, Shape) et examinerons les erreurs typiques : de la tentative de créer une instance d’une classe abstraite à une utilisation incorrecte des modificateurs.