Mon expérience avec la certification OCP Java SE 11

Janvier 2026 : j’ai enfin obtenu la certification OCP Java SE 11 Developer.

Ce fut un parcours intense de plus de 4 mois de préparation. Après avoir échoué deux fois, la troisième tentative a été la bonne. Java cache énormément de subtilités et de comportements “quirky” (parfois inattendus) qui demandent une rigueur absolue.

Voici un tour d’horizon des concepts les plus piégeux que j’ai rencontrés lors de mes révisions.

Strings & String Pool

L’un des sujets préférés de l’examen est la gestion de la mémoire des Strings. Comprendre la différence entre le String Pool et le Heap est crucial.

String a = "hello";
String b = "hello";
String c = new String("hello");

System.out.println(a == b);      // true  — même référence dans le pool
System.out.println(a == c);      // false — c est sur la heap (hors pool)
System.out.println(a.equals(c)); // true  — les valeurs sont identiques

Promotion Numérique et Cache

Les types primitifs ont aussi leurs secrets. Saviez-vous que byte, short et char sont systématiquement promus en int lors d’une opération arithmétique ?

byte b = 10;
b = b + 1;    // ERREUR de compilation : le résultat est un int
b += 1;       // OK : les opérateurs composés effectuent un cast automatique
b = (byte)(b + 1); // OK : cast explicite

Hiding vs Overriding

C’est probablement le piège le plus vicieux : la différence entre la redéfinition (overriding) et le masquage (hiding).

• Les méthodes d’instance sont redéfinies (polymorphisme).
• Les méthodes statiques et les variables sont masquées.

class Parent {
    static void greet() { System.out.println("Hello from Parent"); }
}
class Child extends Parent {
    static void greet() { System.out.println("Hello from Child"); }
}

Parent p = new Child();
p.greet(); // Affiche "Hello from Parent" ! La résolution est faite au type de la référence.

La Hiérarchie des Exceptions

Il est essentiel de distinguer les exceptions Checked des Unchecked.

Effectively Final

Les lambdas peuvent capturer des variables locales, mais à une condition : elles doivent être effectively final.

int x = 10;
Runnable r = () -> System.out.println(x); // OK
// x = 20; // Si on décommente ceci, la lambda au-dessus ne compilera plus !