Java orienté objet : concevoir des programmes robustes
Java orienté objet est un cours de niveau intermédiaire de 6 leçons (environ 4 h), avec 18 exercices et 18 questions de quiz. Prérequis : Java fondamentaux. Les exercices sont exécutés et corrigés dans une sandbox côté serveur.
- Java
- Intermédiaire
- 6 leçons
- 4 h
- 18 exercices
- Exercices exécutés dans une sandbox serveur
Le cours en bref
Ce cours vous apprend à concevoir des programmes Java orientés objet, de la première classe jusqu'à un petit modèle métier complet. Vous verrez l'encapsulation et les records, l'héritage et le polymorphisme, les interfaces, les types scellés et le pattern matching (avec la variable anonyme _ et les constructeurs flexibles de Java 25), le contrat equals/hashCode, puis les génériques et la composition. Tous les exercices sont des programmes complets vérifiés automatiquement.
Ce que tu sauras faire
- Concevoir des classes encapsulées qui garantissent leurs invariants
- Utiliser records et objets immuables pour représenter des données
- Exploiter héritage, classes abstraites et polymorphisme à bon escient
- Définir des contrats avec des interfaces et modéliser des cas fermés avec sealed et le pattern matching
- Implémenter correctement equals et hashCode et utiliser les membres static
- Écrire du code générique et préférer la composition à l'héritage
Programme des 6 leçons
- Définir une classe avec attributs, constructeur et méthodes
- Créer des objets avec new et appeler leurs méthodes
- Comprendre this, les références et null
- 02
Encapsulation, immutabilité et records
- Protéger l'état d'un objet avec private, getters et validation
- Écrire des classes immuables
- Utiliser les records pour les objets de données
- 03
Héritage, classes abstraites et polymorphisme
- Créer une hiérarchie de classes avec extends et super
- Redéfinir des méthodes avec @Override
- Exploiter le polymorphisme avec des classes abstraites
- 04
Interfaces, types scellés et pattern matching
- Définir des contrats avec des interfaces
- Rendre des objets comparables et triables
- Modéliser des cas fermés avec sealed et le pattern matching de switch (Java 21)
InterfacesComparable et ComparatorTypes scellésPattern matching
- 05
La classe Object : equals, hashCode, toString et membres static
- Redéfinir correctement equals et hashCode
- Comprendre leur rôle dans HashSet et HashMap
- Utiliser à bon escient les attributs et méthodes static
- 06
Génériques et composition : concevoir un modèle objet
- Écrire des classes et méthodes génériques
- Préférer la composition à l'héritage
- Assembler un petit modèle objet cohérent (panier, lignes, remise)
Projet final
Gestion d'une médiathèque orientée objet
Concevez en Java le modèle d'une médiathèque : documents de plusieurs types (livre, DVD, revue) avec une hiérarchie ou une interface scellée, adhérents, emprunts avec date de retour et pénalités de retard calculées selon le type de document. Un programme principal lit des commandes sur l'entrée standard (ajouter, emprunter, rendre, lister) et affiche les résultats.
Livrables
- Code source Java organisé en plusieurs classes, records et interfaces
- Diagramme de classes simple (image ou texte) justifiant les choix héritage, interface ou composition
- Un fichier de commandes d'exemple et la sortie attendue
- README expliquant la compilation, l'exécution et les règles métier
Critères d'évaluation
- Encapsulation stricte : attributs private, invariants validés, collections internes protégées
- Polymorphisme ou pattern matching utilisé pour les règles propres à chaque type de document
- equals et hashCode corrects pour les entités stockées dans des Set ou Map
- Comportements variables injectés plutôt que codés en dur
- Le programme gère les commandes invalides sans s'arrêter
Questions fréquentes
Quels sont les prérequis de ce cours ?
Il faut connaître les bases de Java : variables, conditions, boucles, méthodes, tableaux et ArrayList, telles que présentées dans le cours Java fondamentaux.
Les nouveautés récentes de Java sont-elles abordées ?
Oui. Le cours cible Java 25, la version LTS actuelle : records, interfaces scellées, pattern matching de switch et d'instanceof (finalisés en Java 21), variable anonyme _ (Java 22) et constructeurs flexibles, qui autorisent une validation avant super(...) (Java 25).
Quelle différence entre une interface et une classe abstraite ?
Une interface définit un contrat sans état, qu'une classe peut implémenter en plusieurs exemplaires ; une classe abstraite est un parent unique qui peut contenir des attributs et du code partagé. Le cours explique quand choisir l'une ou l'autre.
Ce cours prépare-t-il à Spring Boot ?
Oui. Encapsulation, interfaces, composition et injection par constructeur sont les fondations de Spring Boot, abordé plus loin dans le parcours développeur web Java.
Ce cours, raconté pour ton métier
Dis ce que tu veux savoir faire : « Java orienté objet » prend sa place dans ton parcours, avec des exemples de ton secteur. Les notions restent celles du cours.