Certification Java 8 niveau 2 - Certified Professional, Java SE 8 Programmer

Ce document présente le contenu et les objectifs de la formation « Certification Java 8 niveau 2 - Certified Professional, Java SE 8 Programmer ». Destinée aux développeurs et professionnels confirmés, cette formation intensive prépare à l’examen Oracle Certified Professional Java SE 8 Programmer, en approfondissant la maîtrise du langage Java 8 et ses concepts avancés.

Objectifs de la certification

La certification Oracle Certified Professional, Java SE 8 Programmer (1Z0-809) atteste d’une parfaite maîtrise de la syntaxe Java 8 et des concepts objets associés. L’examen comprend 85 questions à répondre en deux heures trente, avec un seuil de réussite fixé à 65%. Il est réputé difficile, même pour des développeurs expérimentés, et nécessite une préparation rigoureuse.

Cette formation vise à mettre le candidat dans les meilleures conditions pour réussir l’examen, en insistant sur les points délicats du langage et en évitant les pièges classiques. Elle permet également de renforcer les connaissances Java au-delà de la simple préparation à la certification.

Public concerné et prérequis

Ce cours s’adresse aux développeurs d’applications, responsables informatiques, architectes, chefs de projets, ingénieurs, et autres professionnels souhaitant valider leur expertise Java.

Une bonne maîtrise préalable de Java est indispensable. Une évaluation par QCM est réalisée avant l’inscription. Il est également nécessaire d’avoir suivi la formation Java 8 niveau 1 - Certified Associate Java SE 8 Programmer (JCJ8).

Contenu détaillé de la formation

Conception de classes Java

• Mettre en œuvre l’encapsulation
• Mettre en œuvre l’héritage, y compris les spécificateurs d’accès et la composition
• Mettre en œuvre le polymorphisme
• Redéfinir les méthodes hashCode, equals, et toString de la classe Object
• Créer et utiliser les classes Singleton et les classes non modifiables
• Utiliser le mot-clé static sur les blocs d’instructions, variables, méthodes et classes

Exemple : Redéfinition de la méthode equals dans une classe Personne :

public class Personne {
    private String nom;
    private int age;

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Personne p = (Personne) obj;
        return age == p.age && nom.equals(p.nom);
    }
}

Conception avancée de classes

• Utiliser les classes et méthodes abstraites
• Utiliser le mot-clé final
• Créer des classes emboîtées : static, locales, internes et anonymes
• Utiliser les types énumérés avec méthodes et constructeurs
• Déclarer, implémenter et hériter d’interfaces, utiliser l’annotation @Override
• Créer et utiliser des expressions lambdas

Collections et généricité

• Créer et utiliser des classes génériques
• Utiliser ArrayList, TreeSet, TreeMap, ArrayDeque
• Utiliser les interfaces Comparator et Comparable
• Appliquer les filtres et l’API Stream aux collections
• Utiliser la méthode forEach sur Stream et List
• Filtrer une collection avec des expressions lambdas
• Utiliser les références de méthodes avec l’API Stream

Exemple : Filtrer une liste de nombres pairs avec Stream et lambda :

List<Integer> nombres = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> pairs = nombres.stream()
                             .filter(n -> n % 2 == 0)
                             .collect(Collectors.toList());

Interfaces fonctionnelles prédéfinies

• Utiliser Predicate, Consumer, Function, Supplier du package java.util.function
• Utiliser les versions primitives et binaires des interfaces fonctionnelles
• Utiliser l’interface UnaryOperator

L’API java Stream

• Extraire des données avec peek() et map(), y compris versions primitives
• Rechercher avec findFirst, findAny, anyMatch, allMatch, noneMatch
• Utiliser la classe Optional
• Traiter et calculer avec Stream
• Trier une collection avec Stream
• Stocker les résultats avec collect, grouper et partitionner avec Collector
• Utiliser flatMap()

Exceptions et Assertions

• Utiliser try-catch, throw, catch multi-catch et finally
• Utiliser try-with-resources avec ressources Auto-closeable
• Créer des exceptions personnalisées et ressources Auto-closeable
• Tester les invariants avec assertions

API java SE 8 : Date et temps

• Gérer LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration
• Travailler avec les zones horaires et gérer l’heure d’été
• Formater les dates et temps

Entrées / sorties de base

• Lire et écrire sur la console
• Utiliser BufferedReader, BufferedWriter, File, FileReader, FileWriter
• Utiliser FileInputStream, FileOutputStream, ObjectOutputStream, ObjectInputStream, PrintWriter

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

• Manipuler les chemins avec l’interface Path
• Utiliser la classe Files pour vérifier, lire, supprimer, copier, déplacer, gérer les méta-données
• Utiliser l’API Stream avec NIO.2

Accès concurrents

• Créer des threads avec Runnable, Callable, ExecutorService
• Identifier deadlocks, starvation, livelock, race conditions
• Utiliser synchronized et java.util.concurrent.atomic
• Utiliser collections concurrentes, CyclicBarrier, CopyOnWriteArrayList
• Utiliser le framework Fork/Join
• Utiliser les streams parallèles pour optimiser les performances

Applications d’accès aux bases de données avec JDBC

• Décrire les interfaces Driver, Connection, Statement, ResultSet
• Se connecter à une base via DriverManager et URL jdbc
• Soumettre des requêtes, lire et parcourir les résultats
• Fermer résultats, états et connexions

Internationalisation

• Lire et configurer la langue avec Locale
• Créer et lire un fichier Properties
• Construire et charger un resource bundle pour chaque langue

Travaux pratiques

La formation comprend des tests blancs en anglais, corrigés pour mesurer la progression et insister sur les points faibles. Ces exercices permettent de se familiariser avec le format de l’examen et d’approfondir les notions abordées.

Glossaire des termes clés

• Encapsulation : Technique de programmation qui consiste à cacher les données d’une classe et à ne les rendre accessibles que par des méthodes spécifiques.
• Héritage : Mécanisme permettant à une classe de dériver d’une autre, héritant ainsi de ses propriétés et méthodes.
• Polymorphisme : Capacité d’un objet à prendre plusieurs formes, notamment via la redéfinition de méthodes.
• Classe Singleton : Classe dont une seule instance est créée et accessible globalement.
• Classe abstraite : Classe qui ne peut pas être instanciée et qui peut contenir des méthodes abstraites sans implémentation.
• Interface fonctionnelle : Interface ne contenant qu’une seule méthode abstraite, utilisée notamment avec les expressions lambdas.
• Lambda : Expression permettant de définir une fonction anonyme et concise.
• Stream : Séquence d’éléments sur laquelle on peut effectuer des opérations fonctionnelles (filtrage, tri, transformation).
• Optional : Conteneur pouvant contenir ou non une valeur, utilisé pour éviter les NullPointerException.
• Try-with-resources : Instruction permettant de gérer automatiquement la fermeture des ressources.
• JDBC : API Java permettant d’accéder à une base de données relationnelle.
• Locale : Objet représentant une configuration régionale (langue, pays).
• Resource bundle : Ensemble de fichiers de propriétés utilisés pour l’internationalisation.
• Deadlock : Situation où plusieurs threads se bloquent mutuellement en attendant des ressources.
• Fork/Join : Framework permettant de diviser une tâche en sous-tâches pour un traitement parallèle efficace.

Points clés à retenir

• La certification Java SE 8 Programmer valide une maîtrise avancée du langage et de ses API.
• La formation couvre la conception avancée des classes, les collections, les streams, les exceptions, et la concurrence.
• Une bonne préparation est indispensable, avec des tests blancs pour s’entraîner au format de l’examen.
• La gestion des dates, des entrées/sorties, et l’accès aux bases de données sont également des compétences évaluées.
• L’internationalisation et la programmation fonctionnelle avec les lambdas et interfaces fonctionnelles sont des sujets importants.
• La maîtrise des threads et des problèmes liés à la concurrence est essentielle pour les applications performantes.