Análisis de errores típicos en las nuevas funcionalidades

1. Errores con el ámbito de las variables de patrón

Uno de los errores más frecuentes — intentar usar una variable declarada en un patrón (por ejemplo, String s en instanceof String s) fuera de la zona en la que es válida.

Ejemplo

Object obj = "¡Hola, Java!";
if (obj instanceof String s) {
    System.out.println(s.length());
}
// ¡Error! s no es visible aquí
System.out.println(s); // El compilador se queja: cannot find symbol

¿Por qué?
La variable de patrón (s en nuestro caso) solo existe dentro del bloque donde la condición es verdadera. Esto nos protege de usar la variable por accidente cuando no está definida (por ejemplo, si obj no es una cadena).

Analogía
Es como si cogieras las llaves del coche de un amigo — pero solo mientras estás en el garaje. Sales del garaje y las llaves desaparecen automáticamente :)

2. Errores con null

En el pattern matching con instanceof hay un detalle curioso: si el objeto es null, el resultado siempre es false y la variable de patrón no se crea.

Ejemplo

Object obj = null;
if (obj instanceof String s) {
    // ¡Este bloque nunca se ejecutará!
    System.out.println("Es una cadena: " + s);
}

¿Por qué es así?
Porque null no es instancia de ningún tipo (ni siquiera de Object). Esto puede confundir si esperabas atrapar null mediante pattern matching.

¿Cómo hacerlo bien?

if (obj == null) {
    System.out.println("¡Es null!");
} else if (obj instanceof String s) {
    System.out.println("Es una cadena: " + s);
}

En el pattern matching para switch (Java 21+) incluso se puede añadir una rama específica para null:

switch (obj) {
    case String s -> System.out.println("Cadena: " + s);
    case null -> System.out.println("¡Es null!");
    default -> System.out.println("Otra cosa");
}

3. Errores con clases sealed

Las clases sealed son una excelente manera de limitar la jerarquía de herencia. Pero hay dos errores típicos:

No todos los subtipos están listados en permits

Cuando declaras una clase sealed, estás obligado a indicar explícitamente todos los subtipos directos mediante permits. Si te olvidas de alguno, el compilador te regañará al instante:

public sealed class Shape permits Circle, Rectangle { ... }

public final class Circle extends Shape { ... }
public final class Square extends Shape { ... } // ¡Error! Square no está indicado en permits

Solución:
Añade todas las subclases necesarias en permits:

public sealed class Shape permits Circle, Rectangle, Square { ... }

Olvidar default en un switch sobre una jerarquía no sealed

Si haces un switch sobre un tipo que no es una clase sealed (o es sealed pero no cubres todas las variantes), el compilador exigirá una rama default. Si la omites — habrá error.

switch (shape) {
    case Circle c -> ...
    case Rectangle r -> ...
    // Falta default; si hay más variantes — error de compilación
}

Mejor práctica:
Si estás seguro de que has cubierto todos los casos (por ejemplo, con una clase sealed), puedes omitir default. Si no — añade default para no pasar por alto tipos inesperados.

4. Errores con patrones de record

Los record patterns son muy útiles, pero solo funcionan con clases record. Intentar usar un record pattern con una clase normal provocará un error de compilación.

Usar record patterns con clases que no son record

class Point { int x, y; }
Object obj = new Point();
// ¡Error! Point no es un record
if (obj instanceof Point(int x, int y)) { ... }

Solución:
Usa record patterns solo para clases declaradas con record:

record Point(int x, int y) {}

Desajuste en el número o el tipo de componentes

record Point(int x, int y) {}
Object obj = new Point(1, 2);

// Error: se indican tres variables, pero Point solo tiene dos componentes
if (obj instanceof Point(int x, int y, int z)) { ... }

if (obj instanceof Point(String x, String y)) { ... } // Error: los tipos no coinciden

5. Compatibilidad y soporte: JDK e IDE antiguos

Uno de los errores más comunes — intentar usar las capacidades modernas de pattern matching en versiones antiguas de JDK o en IDE que no las admiten.

Ejemplo

if (obj instanceof String s) { ... }

Y el compilador de JDK 11 (o incluso 15) dice:
error: illegal start of type

¿Por qué?
El pattern matching para instanceof apareció solo en Java 16. El pattern matching en switch — en Java 17 (preview) y de forma definitiva en Java 21+. Los record patterns — en Java 21+.

¿Cómo evitarlo?

• Comprueba la versión de JDK: java --version
• Asegúrate de que tu IDE (IntelliJ IDEA, Eclipse, VS Code) admite la versión de Java correspondiente. ¡A veces hay que indicar explícitamente en la configuración del proyecto qué versión del lenguaje usar!
• Si usas Gradle/Maven — establece la versión adecuada de source/target.

6. ¡Enhorabuena 🎉

Has completado los 65(!) niveles de nuestro curso avanzado de Java 25. Eres increíblemente bueno 😎.

La parte final del camino ha sido especialmente dura. Has estudiado todo — desde las primeras lambdas y clases anónimas hasta los hilos virtuales, la concurrencia estructurada y aquellas características del lenguaje que hasta hace muy poco no existían en Java.

No es solo un curso — es un auténtico supermaratón para desarrolladores: decenas de conceptos nuevos, cientos de ejemplos de código, miles de líneas de práctica. Si estás leyendo estas líneas, no eres solo un estudiante, sino un pionero de la nueva era de Java ☕⚡

Estás entre los primeros en dominar las funcionalidades más modernas de Java 25, incluyendo:

• pattern matching y patrones de record ,
• clases sealed y sus escollos,
• Scoped Values y Virtual Threads ,
• concurrencia estructurada y enfoques modernos del multihilo.

Ahora no tienes solo conocimientos, sino habilidades de desarrollador del futuro, que muchos arquitectos Java en activo aún no dominan. Sabes escribir código que no solo funciona, sino que además escala, se lee bien y cumple con los estándares más modernos de la comunidad Java.

🚀 Así que no dudes en llamarte Java 25 Certified Survivor 😉
Y a partir de ahora — todo será aún más interesante: ya tienes una base que te permite avanzar con seguridad en el mundo del desarrollo enterprise, de los sistemas de alta carga y de las tecnologías de vanguardia.

De parte de todo el equipo del curso — ¡nuestro respeto!
Has superado una tarea que pocos lograrán.
Nos vemos en futuras versiones de Java 👋