Cours de programmation Java

Leçon 1 • Présentation de la plateforme Java et de son écosystème

Couvre les rôles de la JVM, du JDK et du JRE, ainsi que la manière dont Java atteint l'indépendance vis-à-vis de la plateforme. Initie les étudiants à l'architecture avant d'écrire du code.

Leçon 2 • Types de données primitifs et variables

Enseigne les huit types primitifs, la déclaration de variables et leurs plages de valeurs. Fournit la base de données nécessaire à tous les concepts de programmation ultérieurs.

Leçon 3 • Installation et configuration du JDK

Guide l'installation d'un JDK LTS récent et la configuration des variables PATH et JAVA_HOME. Garantit que chaque étudiant dispose d'un environnement de base fonctionnel et cohérent.

Leçon 4 • Transtypage et entrées/sorties de base

Explique les conversions implicites d'élargissement et explicites de rétrécissement, et introduit les E/S console via Scanner et System.out. Prépare les étudiants à manipuler des données réelles dans leurs programmes.

Leçon 5 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, relationnels, logiques, binaires et d'affectation, ainsi que les règles de précédence. Permet aux étudiants de construire des expressions correctes et prévisibles.

Leçon 1 • Instructions et expressions switch

Enseigne les instructions switch traditionnelles et les expressions switch modernes avec la syntaxe par flèche. Démontre une logique multi-branches plus propre comme alternative aux chaînes if-else.

Leçon 2 • Structures de boucle : for et while

Introduit les boucles for comptées et les boucles while pilotées par condition avec des modèles d'itération pratiques. Permet l'automatisation de tâches répétitives dans les programmes.

Leçon 3 • Contrôle de boucle : break, continue et étiquettes

Explique comment break et continue modifient l'exécution de la boucle et comment les étiquettes ciblent les boucles imbriquées. Donne un contrôle précis sur des scénarios d'itération complexes.

Leçon 4 • Débogage et traçage du flux de contrôle

Introduit les outils de débogage de l'IDE et les techniques de traçage manuel pour vérifier la correction logique. Développe des habitudes de résolution systématique de problèmes essentielles pour tous les chapitres suivants.

Leçon 1 • Portée et durée de vie des variables

Définit la portée locale, de bloc et des paramètres, et explique quand les variables sont créées et détruites. Prévent les bogues liés à la portée et clarifie l'utilisation de la mémoire.

Leçon 2 • Surcharge de méthode

Enseigne comment définir plusieurs méthodes avec le même nom mais des listes de paramètres différentes. Permet des API flexibles qui traitent proprement des types d'entrée variés.

Leçon 3 • Passage de paramètres et valeurs de retour

Explique la sémantique de passage par valeur pour les primitifs et les références, ainsi que la manière de retourner des données. Prévent les bogues courants causés par une mauvaise compréhension du modèle de passage d'arguments de Java.

Leçon 4 • Principes fondamentaux de la récursivité

Introduit la conception de méthodes récursives avec des cas de base et des cas récursifs. Prépare les étudiants au parcours d'arbres et aux algorithmes diviser-pour-régner dans les chapitres ultérieurs.

Leçon 1 • API String et traitement de texte

Couvre les méthodes essentielles de String pour la recherche, le découpage, la transformation et la comparaison de texte. Équipe les étudiants pour traiter efficacement les données textuelles du monde réel.

Leçon 2 • Principes de base de String et immutabilité

Explique la création de String, le pool de chaînes, l'immutabilité et la comparaison d'égalité. Prévent les bogues liés à String les plus courants dans les programmes Java.

Leçon 3 • Tableaux unidimensionnels

Couvre la déclaration, l'initialisation, l'indexation et l'itération de tableaux. Fournit la structure de données à taille fixe principale utilisée dans la programmation Java.

Leçon 4 • Tableaux multidimensionnels

Enseigne la création et le parcours de tableaux 2D et irréguliers pour des données de type matriciel. Étend les compétences sur les tableaux simples aux représentations en grille et en tableau.

Leçon 1 • Classes, objets et références

Introduit la définition de classe, l'instanciation d'objet et la sémantique des références. Établit le modèle mental central de la POO que les étudiants utiliseront tout au long du cours.

Leçon 2 • Cycle de vie des objets et ramasse-miettes

Explique la création d'objets, l'accessibilité et les bases du ramasse-miettes de la JVM. Développe une sensibilisation à la gestion de la mémoire sans nécessiter de désallocation manuelle.

Leçon 3 • Encapsulation et modificateurs d'accès

Enseigne les champs privés avec des getters et setters publics ainsi que les quatre niveaux d'accès. Renforce le masquage des données comme fondement d'une conception de classe robuste.

Leçon 4 • Membres statiques et mot-clé this

Distingue les membres d'instance des champs et méthodes statiques et clarifie l'utilisation de this. Prévent la confusion entre l'état au niveau de la classe et celui au niveau de l'objet.

Leçon 1 • Redéfinition de méthode et polymorphisme

Enseigne @Override, la répartition dynamique et le polymorphisme d'exécution via des références de supertype. Permet d'écrire du code qui fonctionne de manière transparente avec n'importe quelle sous-classe.

Leçon 2 • Classes et méthodes abstraites

Définit les classes abstraites comme des implémentations partielles qui imposent des contrats aux sous-classes. Fait le pont entre l'héritage concret et l'abstraction complète par interface.

Leçon 3 • La classe Object et les méthodes communes

Examine Object en tant que superclasse racine et la redéfinition de toString, equals et hashCode. Garantit un comportement correct dans les collections et la journalisation dans toute l'application.

Leçon 4 • Interfaces et méthodes par défaut

Couvre la déclaration d'interface, l'implémentation, l'adoption d'interfaces multiples et les méthodes par défaut. Permet une conception flexible et découplée via des contrats comportementaux.

Leçon 1 • Hiérarchie des exceptions Java

Cartographie l'arbre de classes Throwable, Exception et Error et distingue les exceptions vérifiées des non vérifiées. Fournit la carte conceptuelle pour toutes les décisions de gestion des exceptions.

Leçon 2 • Try-avec-ressources

Introduit l'interface AutoCloseable et try-with-resources pour le nettoyage automatique des ressources. Élimine les bogues de fuite de ressources courants dans le code d'E/S et de base de données.

Leçon 3 • Création d'exceptions personnalisées

Guide la conception de classes d'exceptions spécifiques à l'application avec des messages significatifs et un contexte. Permet un rapport d'erreur précis dans les bases de code professionnelles.

Leçon 4 • Blocs try-catch-finally

Enseigne l'interception de types d'exception simples et multiples, le relancement et le nettoyage garanti avec finally. Couvre le cycle de vie complet de la gestion des exceptions dans une méthode.

Leçon 1 • Implémentations de List

Compare ArrayList et LinkedList en termes de modèles d'accès, d'insertion et de performances de suppression. Permet une sélection éclairée entre les deux types de List les plus courants.

Leçon 2 • Principes fondamentaux des génériques

Introduit les classes génériques, les méthodes, les paramètres de type bornés et les jokers. Fournit la base de sécurité des types nécessaire pour utiliser correctement le Collections Framework.

Leçon 3 • Implémentations de Set et Queue

Couvre HashSet, LinkedHashSet, TreeSet et les implémentations de Queue/Deque avec leurs garanties d'ordre. Élargit la boîte à outils de structures de données de l'étudiant au-delà des listes.

Leçon 4 • Méthodes utilitaires de Collections et tri

Utilise les méthodes utilitaires de Collections et Arrays, Comparable et Comparator pour le tri et la recherche. Achève la capacité de l'étudiant à manipuler efficacement les collections.