Caractéristiques du langage

Processus de développement de la plateforme

Panorama des principales éditions et distributions

Principe de la machine virtuelle Java (JVM)

Gestion de la mémoire et principe du garbage collector

Java Runtime Environment (JRE) et Java Development Kit (JDK)

Anatomie d'un fichier source, compilation et exécution d'un programme

Écrire une classe "main" pour lancer un programme

Déclarer des variables, les règles de nommage associées, le mot-clé "var"

Utiliser les types primitifs et les chaînes de caractères

Les instructions conditionnelles "if..else" et "switch"

Expressions switch avec l'opérateur flèche

Répéter une action avec les boucles "for", "while" et "do..while"

Utiliser les opérateurs conditionnels et les opérateurs de comparaison

Commenter le code et générer une documentation HTML

Notion d'annotation, cas de @Deprecated et @SuppressWarning

Introduction à la conception objet, notions de classes et d'instance

Utiliser l'opérateur "new" pour produire des objets

Définir des champs d'instance et différences avec les variables locales

Anatomie d'une méthode : arguments, type de retour, mots-clés "return" et "void"

Principe de la surcharge des méthodes (overloading)

Passer des paramètres variables à une méthode avec l"opérateur "..."

Rôle des constructeurs dans le processus d'instanciation

Utiliser le mot-clé "this" pour référencer une instance

Le mot-clé "static" pour déclarer des champs et des méthodes de classe

Utiliser le mot-clé "final" avec une variable, cas particulier des constantes

Ensemble fini de constantes avec les types énumérés

Stocker des éléments dans un tableau, initialisation, accès aux éléments

Parcourir un tableau avec les boucles "for" et "for each"

Définir des associations entre les classes (one-to-one, many-to-one, one-to-many)

Utiliser les packages pour organiser les classes

La clause "import" et sa relation avec les packages

Comprendre le principe d'encapsulation

Notion de visibilité pour contrôler l'accès aux membres d'une classe

Rôle des méthodes getter et setter vis-à-vis de l'encapsulation

Notion de propriété Java suivant la norme JavaBean

Écrire une classe simplifiée avec la syntaxe record

Accéder aux méthodes de classe avec les imports statiques

Comprendre la technique d'héritage entre classes

Définition et mise en oeuvre du polymorphisme

Principe de la redéfinition des méthodes (overriding)

Intérêt de l'annotation @Override avec une redéfinition

La classe Object, redéfinir les méthodes toString et equals

Transtypage (up et down casting), mot-clé "instance of" et pattern matching

Le mot-clé "final" appliqué aux méthodes et aux classes

Redéfinition des constructeurs, cas particulier du constructeur vide

Utiliser le mot-clé "super" lors d'une redéfinition

Comprendre les notions de classe abstraite et d'interface

Méthodes "default", "static" et "private" dans une interface

Définir des classes internes et cas d'usage

Notions de classes et interfaces scellées, le mot-clé "sealed"

Présentation de la notion d'exception en Java

Description de quelques exceptions classiques du JDK

Comprendre le mécanisme de propagation des exceptions

Traiter une exception avec un bloc "try..catch"

Utiliser un bloc "finally" lors du traitement d'une exception

Rôle des clauses "throw" et "throws" dans la propagation des exceptions

Les exceptions contrôlées et les exceptions non-contrôlées

Exceptions chaînées et analyse de la stacktrace

Créer des classes d'exception personnalisées

Objets AutoCloseable et "try-with-resources"

Notion de classpath pour la compilation et l'exécution

Préparer le déploiement avec un fichier JAR

Cas particulier des fichiers JAR exécutable

Ajouter un fichier JAR dans le classpath

Chaînes de caractères, les classes String et StringBuilder

Méthodes et classes de formatage, utiliser un bloc de texte

Les classes wrappers, mécanismes de boxing et unboxing

Opérations mathématiques avec la classe Math

Données temporelles, la classe Date et l'API Java Time

Méthodes utilitaires des classes System, Arrays et Objects

Limitation des tableaux, apport des collections

Les types de base Collection, List, Set et Map

Principe de la généricité appliquée aux collections

Parcourir une collection avec un itérateur et une boucle "for each"

Rôle et implémentation de la méthode hashCode()

Trier une collection à l'aide des interfaces Comparable et Comparator

Notion d'interface fonctionnelle, l'annotation @FunctionalInterface

Anatomie d'une expression lambda, l'opérateur flèche

Interfaces fonctionnelles standards Predicate, Consumer, Supplier et Function

Implémenter un Comparator avec une lambda

Utiliser une référence de méthode à la place d'une lambda

Principe des streams pour traiter les données en flux

Obtenir un stream à partir d'une source de données

Traitement avec les opérations intermédiaires et terminales

Les principales opérations filter, map, findFirst, forEach

Récupérer le résultat avec les classes Optional et Collector

Le modèle de programmation de l'API JDBC

Se connecter à une base de données

Exécuter des requêtes SQL et exploiter les résultats

Mise en oeuvre de la gestion transactionnelle

Gérer les exceptions générées par l'API