Préparation à la certification Java 17 - Certified Professional Java SE 17 Developer («JAV17»)

Présentation de la certification "OCP Java SE 17 Developer"

• Présentation des différentes certifications Java d'Oracle 
• Déroulement du processus d'inscription  
• Déroulement de l'épreuve 
• Recommandations pour le passage de l'examen 
• Stratégies gagnantes 
• Contenu détaillé de la certification OCP (1ZO-829)

Révisions
Chap.1 - Construction de blocs

• Différentes catégories de variables, portée et cycle de vie 
• Type primitifs, conversions implicites et explicites (cast) 
• Structure d'une classe : attributs, constructeurs, méthodes 
• Accès aux attributs d'un objet 
• Portée et cycle de vie d'un objet 
• Création d’objets 
• Compiler/exécuter un programme Java en ligne de commande 
• Importer des classes d'autres packages  
• Comparer et distinguer les caractéristiques de Java comme: indépendance de la plateforme, orienté objet, l'encapsulation, etc…

Chap.2 - Opérateurs

• Utiliser les opérateurs Java, priorité des opérateurs 
• Opérateurs unaires, binaires, ternaire 
• Opérateurs arithmétiques, sur bits, de comparaison, parenthèses, d’affectation 
• Comparaison des objets en utilisant == et la méthode equals 
• Affectations simples et calculée

Chap.3 - Décisions

• Utiliser les branchements avec if, if/else et l'opérateur ternaire 
• Utiliser l'instruction switch dans ses différentes syntaxes, notamment yield 
• Utiliser l’opérateur instanceof et le Pattern Matching 
• Créer et utiliser les boucles while 
• Créer et utiliser les boucles for y compris la boucle for-each 
• Créer et utiliser les boucles do-while 
• Utiliser les instructions break et continue

Chap.4 - API essentielles

• Manipuler les chaînes de caractères avec les classes String et StringBuilder 
• Manipuler les blocs de texte 
• Déclarer, instancier et manipuler des tableaux à une dimension 
• Déclarer, instancier et manipuler des tableaux à plusieurs dimensions 
• Les méthodes de la classe Math 
• Utiliser les méthodes des classes LocalDate, LocalTime, LocaDateTime, Instant, TimeZone, Period, Duration 
• Formater les dates et le temps 
• Gérer les zones géographiques 
• Calculer les durées avec les classes Period et Duration 
• Compatibilité des nouvelles classes avec les classes java.util.Date et java.util.Calendar

Chap.5 - Méthodes

• Conception de méthodes 
• Déclaration de variables locales et d’instance 
• Utilisation de paramètres varargs 
• Modificateurs d’accès 
• Accès aux membres static 
• Passage d’arguments aux méthodes 
• Surcharge de méthodes

Chap.6 - Conception de classes

• Appliquer aux classes les principes de l'encapsulation 
• Distinguer le constructeur par défaut des constructeurs définis par l'utilisateur 
• Appliquer les modificateurs d'accès 
• Créer des méthodes avec arguments et valeur de retour 
• Cycle de vie des variables locales 
• Surcharger des méthodes, notamment les constructeurs 
• Maîtriser le passage d'arguments aux méthodes par valeur et par référence 
• Appliquer le mot-clé static aux attributs et aux méthodes 
• Les blocs d’initialisation, les blocs static 
• Méthodes par défaut, privées et méthodes static dans les interfaces 
• Utiliser des classes et des objets immutable 
• Utiliser les classes et les méthodes abstraites 
• Développer du code qui utilise le mot-clé final  
• Décrire le principe de l'héritage et ses bénéfices 
• Utilisation de l’opérateur instanceof 
• Utiliser les mot-clés this et super pour l'accès aux objets et aux constructeurs 
• Hériter de classes abstraites

Chap.7 - Au-delà des classes

• Créer des classes emboîtées static, les classes locales, classes internes et anonymes 
• Implémenter des interfaces 
• Utiliser les types énumérés, y compris ceux comportant des méthodes et des constructeurs 
• Créer/utiliser des records 
• Créer/utiliser des classes ou interfaces scellées 
• Décrire le principe de l'héritage et ses bénéfices 
• Mettre en œuvre le polymorphisme, redéfinir des méthodes 
• Savoir déterminer quand un cast est nécessaire 
• Utilisation de l’opérateur instanceof 
• Hériter de classes abstraites et implémenter des interfaces

Chap.8 - Expressions Lambdas et interfaces fonctionnelles

• Comprendre les principes de la programmation fonctionnelle
• Syntaxe des classes internes anonymes
• Notion d’interface fonctionnelle
• Anatomie d'une Expression Lambda
• Mise en œuvre des interfaces fonctionnelles prédéfinies : Consumer, Supplier, Predicate, Function, UnaryOperator, BinaryOperator
• Variantes spécialisées pour types primitifs des interfaces fonctionnelles prédéfinies

Chap.9 - Collections et généricité

• Utilisation des classes enveloppes
• Principe de l’autoboxing
• Créer et utiliser une classe générique
• Créer et utiliser une méthode générique
• Utilisation du caractère ? dans un paramètre générique
• Présentation des interfaces List, Set, DeQue, Map
• Savoir choisir un type de collection
• Créer et utiliser les objets ArrayList, TreeSet, TreeMap et ArrayDeque
• Parcours de collections avec itérateur ou boucle for-each
• Rôle des méthodes equals et hashCode
• Utilisation des classes enveloppes
• Méthodes de la classe Collections

Chap.10 - Streams

• Obtention de streams
• Méthodes intermédiaires et terminales
• Exploiter les méthodes peek et map, y compris les versions primitives de map ainsi que flatMap
• Rechercher des données au moyen de méthodes des classes de l’API Stream comme findFirst, findAny, anyMatch, allMatch, noneMatch
• Savoir utiliser les méthodes groupingBy et partitioningBy
• Utiliser les méthodes de la classe Optional
• Trier une collection au moyen de l’API Stream
• Utiliser les méthodes reduce et collect pour effectuer des réductions
• Principe de l’évaluation paresseuse
• Streams sur types primitifs
• Utiliser les streams parallèles pour améliorer les performances

Chap.11 - Gestion des exceptions et Internationalisation

• Distinguer les exceptions contrôlées des exceptions non contrôlées, ainsi que des Errors
• Créer un bloc try-catch et déterminer comment les exceptions modifient le déroulement normal du programme
• Décrire les avantages de la gestion d'exceptions
• Rôle de finally
• Mise en œuvre du try-with-resources
• Créer et invoquer une méthode qui lance une exception
• Reconnaître les classes d'exceptions courantes
• Lire et configurer la langue/le pays avec un objet Locale
• Formater les dates et le temps
• Gérer les zones géographiques
• Gestion des Resource Bundles
• Créer et lire un fichier Properties
• Créer un fichier Properties par langue et le charger dans l’application via un resource bundle
• Formatage des nombres et des dates

Chap.12 - Mise en œuvre des modules

• Notion de module, format du descripteur de module
• Directives export, requires, uses, provides, opens
• Mise en oeuvre de modules
• Gestion des dépendances entre modules
• Compilation/exécution d’un projet modulaire
• Rôle du modulepath
• Nouvelle organisation de la documentation des API Java 
• Modules nommés, anonymes et automatiques
• Mise en œuvre de services
• Utiliser la commande jdeps
• Migration d’une application non modulaire vers une application modulaire
• Créer des fichiers jar modulaires ou non
• Créer des images exécutables avec jlink

Chap.13 - Les accès concurrents en multi-threadin

• Créer des threads avec Runnable, Callable 
• Utiliser un ExecutorService pour exécuter les tâches
• Identifier les problèmes potentiels du multi-threading parmi les deadlocks, starvation, livelock, race conditions
• Utiliser le mot-clé synchronized, les verrous Lock
• Utiliser les classes Atomic
• Utiliser les collections java.util.concurrent et les classes CyclicBarrier et CopyOnWriteArrayList
• Utiliser le framework Fork/Join

Chap.14 - Entrées/sorties

• Savoir choisir entre les hiérarchies InputStream/OuputStream et Reader/Writer
• La classe File
• Lire des données au clavier et écrire sur la console
• Utiliser les classes du package java.io, notamment BufferedReader, BufferedWriter, File, FileReader, FileWriter, FileInputStream, FileOutputStream, PrintWriter
• Mettre en œuvre la sérialisation d’objet avec ObjectOutputStream, ObjectInputStream
• Streams sur fichiers
• Utilisation de l’interface Path pour manipuler les chemins de répertoires ou de fichiers
• Manipulation de fichiers/répertoires avec la classe Files 
• Gérer les attributs d’un fichier ou répertoire et autres méta-données
• Utiliser l’API Stream sur fichiers et répertoires

Chap.15 - Accès aux bases de données avec JDBC

• Rôle d’un driver JDBC
• Utiliser la classe DriverManager pour se connecter à une base de données
• Mettre en oeuvre les interfaces Connection, Statement, PreparedStatement, CallableStatement et ResultSet 
• Emettre des requêtes SQL et lire les résultats de la base de données : parcours des résultats, fermeture des résultats, des états et des connexions
• Gestion des exceptions SQLException
• Gestion des transactions avec l’API JDBC

Ce cours est composé des modules suivants

• Préparation à la certification Java 17 partie 1 - Certified Professional Java SE 17 Developer («JAV17A»)
• Préparation à la certification Java 17 partie 2 - Certified Professional Java SE 17 Developer («JAV17B»)

Cette formation s'adresse aux développeurs qui souhaitent se préparer au passage de l’examen officiel 1ZO-829 d'Oracle, permettant d'obtenir la certification « Oracle Certified Professional - Java SE 17 Developer ».

Pour tirer pleinement profit de cette formation de préparation à l'examen de certification, il est nécessaire d'avoir au préalable de bonnes bases en programmation Java 17 ainsi qu'une bonne pratique.

Cette formation permet de se préparer à l'examen de la certification « Oracle Certified Professional - Java SE 17 Developer ».

L'examen 1Z0-829 dure 1h30, et nécessite de répondre à 50 questions de type QCM. Il est attendu un minimum de 68% de bonnes réponses.

L'examen de certification n'est pas compris dans la formation. Vous pourrez vous y inscrire directement auprès d'Oracle.