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

Présentation de la certification "OCP Java SE 11 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-819)

Révisions
Bases de Java

• 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
• 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…

Opérateurs et des branchements conditionnels

• Utiliser les opérateurs Java, priorité des opérateurs
• Opérateurs arithmétiques, sur bits, de comparaison, parenthèses, d’affectation
• Comparaison des objets en utilisant == et la méthode equals
• Utiliser les branchements avec if, if/else et l'opérateur ternaire
• Utiliser l'instruction switch

Utilisation des boucles

• 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

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
• Les classes abstraites
• Introduction aux classes emboîtées

Mise en œuvre de l'héritage

• 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
• Utiliser les mot-clés this et super pour l'accès aux objets et aux constructeurs
• Hériter de classes abstraites et implémenter des interfaces

Gestion des exceptions

• 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

Utilisation de classes de l'API Java

• Manipuler les chaînes de caractères avec les classes String et StringBuilder
• Déclarer, instancier et manipuler des tableaux à une dimension
• Déclarer, instancier et manipuler des tableaux à plusieurs dimensions
• Manipuler les tableaux avec les méthodes de la classe Arrays
• Déclarer et utiliser une ArrayList
• Utilisation des classes enveloppes
• Principe de l’autoboxing
• Les collections de type Set et Map
• Les méthodes de la classe Math

Expressions Lambdas

• 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 Consumer, Supplier, Predicate, Comparator

Mise en œuvre des modules

• Notion de module, format du descripteur de module
• Directives export, requires, uses, provides, opens
• Mise en œuvre de modules
• Accès aux modules de la bibliothèque Java
• Compilation/exécution d’un projet modulaire
• Commandes jdeps et jlink

Nouveautés dans les interfaces

• Méthodes par défaut et méthodes static
• Méthodes privées

Annotations

• Format d’une annotation
• Annotations prédéfinies de Java 11
• Création d’annotations
• Meta-annotations
• Annotations de type
• Annotations répétées

Conception avancée de classes

• Méthodes par défaut, privées et méthodes static dans les interfaces
• Utiliser les classes et les méthodes abstraites
• Développer du code qui utilise le mot-clé final
• Créer des classes emboîtées static, les classes locales, classes internes et anonymes
• Utiliser les types énumérés, y compris ceux comportant des méthodes et des constructeurs

Collections et généricité

• 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, Queue, 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

Programmation fonctionnelle

• 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
• 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
• Utiliser les streams parallèles pour améliorer les performances

Date/temps-Internationalisation

• Utiliser les méthodes des classes LocalDate, LocalTime, LocaDateTime, Instant, 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
• Obtention d’un objet Locale
• Localisation de dates, nombres
• Gestion des Resource Bundles

Entrées/sorties de base

• 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

Entrées/sorties sur fichiers (NIO.2)

• 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

Les accès concurrents en multi-threading

• Créer des threads avec Runnable, Callable
• Utiliser un ExecutorService pour exécuter les tâches
• Identifer 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

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
• Émettre 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

Mise en œuvre des modules

• Modules nommés, anonymes et automatiques
• Directives
• Mise en oeuvre de modules
• Gestion des dépendances entre modules
• Rôle du modulepath
• Mise en œuvre de services
• Nouvelle organisation de la documentation des API Java
• Utiliser la commande jdeps
• Migration d’une application non modulaire vers une application modulaire

Internationalisation

• Lire et configurer la langue/le pays avec un objet Locale
• 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

Sécurité

• Conception sûre d’une classe
• Validation des saisies
• Protection ds données sensibles
• Sérialisation d’objets
• Prévention des attaques par déni de service
• Lecture attentive de « Secure Coding Guidelines for Java SE » fourni par Oracle

 

Ce cours est composé des modules suivants

• Préparation à la certification Java 11 partie 1 - Certified Professional Java SE 11 Developer («JAV11A»)
• Préparation à la certification Java 11 partie 2 - Certified Professional Java SE 11 Developer («JAV11B»)

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

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

Cette formation est une préparation à l'examen 1Z0-819 de la certification « Oracle Certified Professional - Java SE 11 Developer ».

L'examen dure 90 minutes et nécessite de répondre à 50 questions de type QCM. Un minimum de 68% de bonnes réponses est attendu.

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