Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

Maîtrisez Java — Avancé

Découvre les mécanismes avancés de Java : génériques, concurrence, gestion de mémoire, réflexion et traitement de données en mémoire. Exerce-toi aussi aux règles temporelles et aux démonstrations d'empreintes, HMAC et AES/GCM.

APERÇU DU COURSPRÊT
Leçons : 63
Quiz : 11
Toutes les étapes : 74
$Prêt à commencer
Base de connaissances de cette technologie

Ce que vous apprendrez

  • Utiliser des contraintes génériques avancées, collections et mécanismes de traitement des données en tenant compte des contrats de types.
  • Coordonner threads et tâches avec les verrous, outils de synchronisation, opérations atomiques, files et CompletableFuture.
  • Comprendre l'accessibilité des objets en mémoire et les références et utiliser réflexion, annotations, proxy, MethodHandle et VarHandle.
  • Traiter les tampons, encodages, sérialisation et dates et distinguer les démonstrations cryptographiques des mécanismes requis dans un système réel.

Programme du cours

Suivez le programme étape par étape. Les étapes terminées sont signalées et vous pouvez ouvrir la prochaine étape disponible.

63 leçons11 quiz74 étapes au total
  1. 01LEÇON
    LEÇON 1 : Immutabilité « deep » – concevoir des classes à l'abri des fuites et de l'aliasingDisponible maintenant
  2. 02LEÇON
    LEÇON 2 : Publication d'objets – exposition sûre de l'état, copies défensivesVerrouillé
  3. 03LEÇON
    LEÇON 3 : CRTP en Java (self-type) – fluent API avec des génériques auto-référentsVerrouillé
  4. 04LEÇON
    LEÇON 4 : Classes basées sur la valeur — identité, égalité et cache des wrappersVerrouillé
  5. 05LEÇON
    LEÇON 5 : equals/hashCode/compareTo avancés pour les hiérarchies et les ordresVerrouillé
  6. 06LEÇON
    LEÇON 6 : Copie d'objets – constructeur de copie, copie profonde et problèmes avec cloneVerrouillé
  7. 01QUIZ
    Quiz 1 : leçons 1–6Verrouillé
  8. 07LEÇON
    LEÇON 7 : Hiérarchie fermée de paiements avec sealed interfaceVerrouillé
  9. 08LEÇON
    LEÇON 8 : record comme support de données – contrats et modèles d'utilisationVerrouillé
  10. 09LEÇON
    LEÇON 9 : switch expression et pattern matching instanceofVerrouillé
  11. 10LEÇON
    LEÇON 10 : Conception « DTO vs domain » – conversions et séparation des responsabilitésVerrouillé
  12. 11LEÇON
    LEÇON 11 : Génériques – contraintes récursives (T extends Comparable<? super T>)Verrouillé
  13. 12LEÇON
    LEÇON 12 : Wildcard Capture – helpers qui réparent les types « sauvages »Verrouillé
  14. 02QUIZ
    Quiz 2 : leçons 7–12Verrouillé
  15. 13LEÇON
    LEÇON 13 : Effacement de types en Java : conséquences et contournements avec Class<T> (jetons de type)Verrouillé
  16. 14LEÇON
    LEÇON 14 : Varargs avec génériques – @SafeVarargs et éviter la pollution du tasVerrouillé
  17. 15LEÇON
    LEÇON 15 : Méthodes génériques – inférence, contraintes à bornes multiplesVerrouillé
  18. 16LEÇON
    LEÇON 16 : Builder générique — API extensible et sûre du point de vue des typesVerrouillé
  19. 17LEÇON
    LEÇON 17 : IdentityHashMap vs HashMap – identité et égalitéVerrouillé
  20. 18LEÇON
    LEÇON 18 : WeakHashMap : sémantique du GC et caches légersVerrouillé
  21. 03QUIZ
    Quiz 3 : leçons 13–18Verrouillé
  22. 19LEÇON
    LEÇON 19 : EnumSet / EnumMap — représentations binaires et performanceVerrouillé
  23. 20LEÇON
    LEÇON 20 : TreeMap / NavigableMap : intervalles, vues et modifications sûresVerrouillé
  24. 21LEÇON
    LEÇON 21 : Vues de collections — unmodifiable*, subList et conséquences du fonctionnement « en direct »Verrouillé
  25. 22LEÇON
    LEÇON 22 : Spliterator - caractéristiques, estimation de la taille, trySplitVerrouillé
  26. 23LEÇON
    LEÇON 23 : Un Spliterator personnalisé pour une structure non standardVerrouillé
  27. 24LEÇON
    LEÇON 24 : Un Collector personnalisé (CONCURRENT / UNORDERED / IDENTITY_FINISH)Verrouillé
  28. 04QUIZ
    Quiz 4 : leçons 19–24Verrouillé
  29. 25LEÇON
    LEÇON 25 : Modèle mémoire de Java (JMM) : « happens-before » en pratiqueVerrouillé
  30. 26LEÇON
    LEÇON 26 : volatile et publication : quand cela suffit et quand cela ne suffit pasVerrouillé
  31. 27LEÇON
    LEÇON 27 : Initialisation à double vérification (Double-Checked Locking) avec volatileVerrouillé
  32. 28LEÇON
    LEÇON 28 : synchronized — moniteurs, portées, erreurs et coûtVerrouillé
  33. 29LEÇON
    LEÇON 29 : ReadWriteLock vs StampedLock (lecture optimiste)Verrouillé
  34. 30LEÇON
    LEÇON 30 : ReentrantLock et Condition : signalisation et timeoutsVerrouillé
  35. 05QUIZ
    Quiz 5 : leçons 25–30Verrouillé
  36. 31LEÇON
    LEÇON 31 : Compteurs sans verrous - LongAdder / LongAccumulatorVerrouillé
  37. 32LEÇON
    LEÇON 32 : Atomic* et CAS — opérations atomiques et updaters de champsVerrouillé
  38. 33LEÇON
    LEÇON 33 : ThreadLocal / InheritableThreadLocal – isolation de l'état et fuitesVerrouillé
  39. 34LEÇON
    LEÇON 34 : Barrières et coordination — CountDownLatch et CyclicBarrierVerrouillé
  40. 35LEÇON
    LEÇON 35 : Phaser – synchronisation en plusieurs étapesVerrouillé
  41. 36LEÇON
    LEÇON 36 : Sémaphores et backpressure — Semaphore et limitation du parallélismeVerrouillé
  42. 06QUIZ
    Quiz 6 : leçons 31–36Verrouillé
  43. 37LEÇON
    LEÇON 37 : Files d'attente bloquantes - ArrayBlockingQueue / LinkedBlockingQueueVerrouillé
  44. 38LEÇON
    LEÇON 38 : PriorityBlockingQueue et SynchronousQueue — scénarios d'utilisationVerrouillé
  45. 39LEÇON
    LEÇON 39 : ForkJoinPool - RecursiveTask et « diviser pour régner »Verrouillé
  46. 40LEÇON
    LEÇON 40 : Work-stealing et commonPool() – conception de tâches récursivesVerrouillé
  47. 41LEÇON
    LEÇON 41 : CompletableFuture - compositions, timeouts, exceptions, allOf/anyOfVerrouillé
  48. 42LEÇON
    LEÇON 42 : CompletableFuture + Executor : contrôle du contexte et backpressureVerrouillé
  49. 07QUIZ
    Quiz 7 : leçons 37–42Verrouillé
  50. 43LEÇON
    LEÇON 43 : Streams parallèles – quand oui/non, effet de bord et ordreVerrouillé
  51. 44LEÇON
    LEÇON 44 : Flow (Reactive Streams) - mini Publisher/Subscriber en mémoireVerrouillé
  52. 45LEÇON
    LEÇON 45 : Références Weak / Soft / Phantom + ReferenceQueue — cycle de vie des objetsVerrouillé
  53. 46LEÇON
    LEÇON 46 : Cleaner - nettoyage « déterministe » des ressources en mémoireVerrouillé
  54. 47LEÇON
    LEÇON 47 : Éviter les fuites — cycles, registres de listeners, cache et maps faiblesVerrouillé
  55. 48LEÇON
    LEÇON 48 : Autoboxing / unboxing en Java : coûts, pièges des comparaisons, micro-optimisationsVerrouillé
  56. 08QUIZ
    Quiz 8 : leçons 43–48Verrouillé
  57. 49LEÇON
    LEÇON 49 : String.intern, StringBuilder vs + dans une boucle – pratiqueVerrouillé
  58. 50LEÇON
    LEÇON 50 : ByteBuffer - allocateDirect, ByteOrder, encodages de caractèresVerrouillé
  59. 51LEÇON
    LEÇON 51 : Base64, Charset, CharBuffer : transcodage en mémoireVerrouillé
  60. 52LEÇON
    LEÇON 52 : Sérialisation binaire en mémoire (ObjectOutputStream ↔ byte[])Verrouillé
  61. 53LEÇON
    LEÇON 53 : Flux de données : DataInputStream / DataOutputStream (protocole simple personnalisé)Verrouillé
  62. 09QUIZ
    Quiz 9 : leçons 49–53Verrouillé
  63. 54LEÇON
    LEÇON 54 : Réflexion profonde en Java : méthodes, champs, constructeurs et annotations à l'exécutionVerrouillé
  64. 55LEÇON
    LEÇON 55 : Proxy dynamiques : InvocationHandler, aspects et journalisationVerrouillé
  65. 56LEÇON
    LEÇON 56 : MethodHandles : lookup, bindTo, invokeExactVerrouillé
  66. 57LEÇON
    LEÇON 57 : VarHandle — accès atomique et ordre des opérations en mémoireVerrouillé
  67. 58LEÇON
    LEÇON 58 : Annotations personnalisées : @Repeatable, héritage (@Inherited), métadonnéesVerrouillé
  68. 10QUIZ
    Quiz 10 : leçons 54–58Verrouillé
  69. 59LEÇON
    LEÇON 59 : Mini « DI » : un conteneur simple basé sur les annotations et la réflexionVerrouillé
  70. 60LEÇON
    LEÇON 60 : java.time avancé : fuseaux horaires, changements d'heure (DST), TemporalAdjustersVerrouillé
  71. 61LEÇON
    LEÇON 61 : Règles de formatage : DateTimeFormatter, parsing et validationsVerrouillé
  72. 62LEÇON
    LEÇON 62 : Cryptographie — SecureRandom, MessageDigest (SHA-256) et comparaison en temps constantVerrouillé
  73. 63LEÇON
    LEÇON 63 : HMAC et chiffrement symétrique en mémoire (Mac « HmacSHA256 », AES/GCM)Verrouillé
  74. 11QUIZ
    Quiz 11 : leçons 59–63Verrouillé
  75. +EXAMEN
    Confirmez vos compétences avec un examenLa préparation avec ce cours est facultative. Vous pouvez choisir un examen de certification pour cette langue et ce niveau sans terminer le cours ni les quiz. Vérifiez l’accès de votre compte et confirmez l’autorisation de l’examen.Autre statut