Cours Initiation POO Java en PDF (Intermédiaire)

Initiation à la programmation orientée‑objet avec le langage Java — support de cours présentant les notions fondamentales de la POO en Java (classes, objets, encapsulation, héritage, polymorphisme dynamique), le pipeline de compilation/exécution autour du bytecode et de la JVM, ainsi que des mécanismes pratiques (gestion des exceptions, flux I/O, Swing, UML). Le PDF est disponible en téléchargement libre et contient des exemples de code téléchargeables et des exercices corrigés Java PDF pour s'exercer.

🎯 Ce que vous allez apprendre

• Environnement d'exécution et bytecode — compréhension précise du pipeline javac → bytecode → JVM et des options de compilation comme -classpath. Vous saurez compiler et exécuter des classes en contrôlant le classpath et les répertoires de sortie. Le document présente aussi le rôle du Garbage Collector : gestion automatique de la mémoire, libération d'objets non référencés et implications sur la conception (absence de destructeurs explicites et utilisation de références faibles pour limiter les fuites). Contrairement au C++, Java ne possède pas de destructeur d'objet explicite, la libération mémoire étant assurée par la JVM.
• Conception de classes et encapsulation — structure d'une classe Java, visibilité des membres et rôle des constructeurs et du mot-clé this. Maîtrise de l'encapsulation pour protéger l'état des objets et écrire des constructeurs robustes permettant d'initialiser correctement des instances. Mention moderne : utilisation de record (Java 14+) pour des types immuables et concis destinés aux DTOs et transport de données ; les records génèrent automatiquement les méthodes d'accès, equals/hashCode et un constructeur canonique, utile pour réduire le code boilerplate.
• Héritage, polymorphisme et interfaces — règles de redéfinition, principe de substitution et distinction entre interfaces et classes abstraites. Conception de hiérarchies de classes favorisant le polymorphisme dynamique et la réutilisation, et utilisation des interfaces pour la réalisation multiple. Un paragraphe spécifique sur le transtypage et la vérification de type se trouve plus bas pour éviter les erreurs courantes au runtime.
• Gestion des exceptions et classification des erreurs — déclaration, interception et bonnes pratiques de traitement des exceptions en Java. Différenciation entre erreurs et exceptions, écriture de blocs try/catch/finally appropriés et définition de classes d'exception adaptées au domaine.
• Entrées/sorties et sérialisation — flux d'entrée/sortie pour lecture clavier, fichiers et enregistrement/lecture d'objets. Manipulation des streams pour persister des données et compréhension des implications de la sérialisation d'objets en Java.
• Éléments de programmation Java et algorithmes — structures de contrôle, méthodes d'instance et méthodes statiques ; implémentation d'algorithmes classiques (tris, recherche) en s'appuyant sur des méthodes de classe et les collections du JDK. Exercices pratiques d'implémentation et optimisation des algorithmes de tri pour différents jeux de données.
• Interfaces graphiques et MVC avec Swing — composants, containers, gestion d'événements et architecture Modèle‑Vue‑Contrôleur. À l'issue, vous saurez esquisser une interface Swing, attacher des listeners et séparer clairement logique métier et présentation. Les Applets ont été largement supplantées ; Swing constitue une option éprouvée pour des applications de bureau, tandis que JavaFX est le successeur moderne pour les interfaces riches.

Le concept de Polymorphisme Dynamique

Le polymorphisme dynamique, ou liaison tardive, désigne la résolution d'un appel de méthode à l'exécution en fonction du type réel de l'objet plutôt que du type de la référence. Concrètement, une référence de type parent peut invoquer une méthode sur une instance d'une sous‑classe et la JVM effectuera le dispatch vers l'implémentation redéfinie (mise en œuvre via une table des méthodes virtuelles). Ce mécanisme est central pour des patterns comme Strategy, State ou Template Method et facilite la programmation orientée‑contrat avec les interfaces.

Maîtriser l'écosystème Java : JDK, JRE et JVM

Le JDK (Java Development Kit) fournit les outils de développement (javac, jar, etc.), tandis que la JVM (Java Virtual Machine) exécute le bytecode. Le JRE (Java Runtime Environment) rassemble la JVM et les bibliothèques nécessaires à l'exécution. Comprendre ces composantes facilite la gestion des versions, la configuration du classpath et l'utilisation d'outils de build. Le document aborde le choix d'une distribution (OpenJDK, Oracle JDK, ou builds packagés) et les vérifications de compatibilité à effectuer pour éviter les incompatibilités : OpenJDK 21, Eclipse Temurin/Adoptium, Amazon Corretto et Azul Zulu figurent parmi les options courantes.

📑 Sommaire

• Introduction au langage Java
• Syntaxe du langage
• Éléments de programmation Java
• Héritage
• Gestion des exceptions
• Gestion des entrées/sorties simples
• Applications graphiques (package swing)
• Diagramme de classes UML

💡 Pourquoi choisir ce cours ?

Rédigé par Gauthier Picard et Laurent Vercouter, le document propose une progression pédagogique claire et des exemples concrets liant conception orientée‑objet et correspondance UML‑Java. L'annexe Swing et le chapitre sur la sérialisation apportent des cas pratiques souvent absents des supports d'initiation, et les exercices corrigés renforcent la mise en pratique. Les exemples fournis sont téléchargeables pour une expérimentation directe.

Syntaxe du langage

Principes de base de la syntaxe Java, types primitifs, conversions et wrappers. Exemples et bonnes pratiques pour éviter les erreurs de transtypage et tirer parti des API du JDK.

Algorithmes et Collections

Présentation des principales collections du JDK : List (ArrayList, LinkedList), Set (HashSet, LinkedHashSet, TreeSet) et Map (HashMap, LinkedHashMap, TreeMap). Le document détaille les propriétés de performance (complexité en lecture/écriture), conseils de choix selon les besoins et bonnes pratiques pour utiliser les itérateurs, streams et opérations immuables. Des exemples illustrent l'usage des génériques et des comparators pour trier des collections et maintenir des structures efficaces.

Algorithmes de tri en Java

Utilisation des utilitaires standards pour implémenter des tris : Arrays.sort() pour tableaux et Collections.sort() pour listes. Ces méthodes acceptent des Comparator pour définir un ordre personnalisé ; pour les types primitifs, les algorithmes fournis sont optimisés. En pratique, privilégier les méthodes standard pour la simplicité et la performance, puis évaluer des optimisations (tri partiel, tri parallèle) selon la taille des données. L'interface Comparable permet d'ordonner des objets.

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

int[] primitives = {3, 1, 2};
Arrays.sort(primitives);

List noms = List.of("Alice","Bob","Charlie");
List modifiable = new ArrayList<>(noms);
Collections.sort(modifiable, Comparator.naturalOrder());

Gestion de la mémoire et cycle de vie des objets

Le document traite de l'allocation d'objets sur le tas, de la notion de portée et de l'importance des références pour la durée de vie des instances. La gestion automatique par le Garbage Collector évite en général le nettoyage manuel ; toutefois, comprendre les graphes d'objets, les références fortes/faibles et la présence de cycles reste essentiel pour prévenir les fuites. Java ne propose pas de destructeurs explicites comme en C++ : la libération mémoire est prise en charge par la JVM. Les finaliseurs existent historiquement mais sont déconseillés ; la méthode finalize() est dépréciée depuis Java 9. Privilégier des patterns explicites (try-with-resources, Closeable) pour les ressources externes.

Comparatif : Classes Abstraites vs Interfaces en Java

Une interface définit des signatures de méthodes et constitue un contrat de comportement, tandis qu'une classe abstraite peut fournir des implémentations partagées et des champs. On implémente plusieurs interfaces mais on n'étend qu'une seule classe, ce qui influe sur la modélisation des responsabilités. Recommandation : préférer une interface pour la flexibilité et la multi‑implémentation, et une classe abstraite lorsque l'on souhaite factoriser du code commun.

Transtypage et vérification de type (instanceof)

Avant d'effectuer un transtypage explicite (cast), vérifier le type réel d'un objet évite les ClassCastException. L'opérateur instanceof permet de tester si une référence est d'un type donné ou d'une de ses sous‑classes. Exemple d'usage sécurisé : tester avec instanceof puis caster. Cette vérification est courante dans les points d'extension où des objets hétérogènes sont manipulés (collections non typées, traitement polymorphe) et s'inscrit dans une pratique défensive pour maintenir la robustesse des API.

Le test de type avec instanceof

Exemple succinct :

Object obj = getSomeObject();
if (obj instanceof String) {
    String s = (String) obj; // transtypage sécurisé après vérification
    System.out.println(s.length());
}

Depuis Java 14, l'usage de instanceof peut être combiné avec le pattern matching pour simplifier le transtypage, réduisant le boilerplate et les risques d'erreur.

❓ Foire Aux Questions (FAQ)

Comment la compilation Java produit-elle du bytecode portable ?

Le compilateur javac traduit le code source en bytecode indépendant de la plateforme, destiné à être interprété ou optimisé par la JVM ; cette couche d'abstraction (bytecode + JVM) permet la portabilité entre systèmes d'exploitation.

Quelle est la différence pratique entre une interface et une classe abstraite en Java ?

Une interface déclare des signatures de méthodes pour être réalisées par des classes multiples, tandis qu'une classe abstraite peut contenir des implémentations et des champs. L'usage dépend du besoin de réutilisation de code ou de séparation des contrats.

Différences entre Java 8, 11 et 21

Les versions LTS (8, 11, 17, 21) apportent des évolutions importantes : API standard enrichies, améliorations de performance et gestion des modules (JPMS à partir de Java 9). Java 8 a introduit les lambdas et les streams, Java 11 a stabilisé plusieurs APIs et apporté des améliorations runtime, et Java 21 (LTS) poursuit l'évolution du langage et des performances. Vérifier la compatibilité des dépendances et la cible de compilation lors du choix d'une distribution (OpenJDK 21 recommandé pour les projets récents).

Conclusion et Perspectives

Ce support intermédiaire fournit les bases solides nécessaires pour progresser vers la POO avancée (design patterns, principes SOLID, optimisation de la mémoire) ou vers des technologies Java d'entreprise (Java EE/Jakarta EE). Pour aller plus loin, explorez les structures de données avancées, le polymorphisme dynamique appliqué aux architectures modulaires et la gestion avancée du cycle de vie des objets. La maîtrise de l'environnement (OpenJDK, JDK 21) et des collections facilitera l'entrée dans des projets réels et la transition vers des sujets avancés.