Novedades de Java 25 LTS: lo que cambia para tu código
Las novedades de Java 25 LTS que más usarás: archivos compactos con main de instancia, import module, código antes de super() y Scoped Values.
En resumen: Java 25 (septiembre de 2025) es la nueva versión LTS tras Java 21. Lo que más se nota al escribir código: archivos de código compactos con
void main()sin clase (JEP 512),import modulepara importar un módulo entero (JEP 511), sentencias antes desuper(...)en constructores (JEP 513) y Scoped Values como alternativa aThreadLocal(JEP 506). Todo lo del ejemplo es estándar, sin--enable-preview. Probado con el JDK 25.0.4.
Vídeo explicativo
Las cuatro novedades en un archivo
Este archivo se ejecuta tal cual con java Main.java, sin compilar antes:
import module java.base; // JEP 511: importa todos los paquetes exportados por java.base
// JEP 513: sentencias antes de super(...) o this(...)
class Temperatura {
final double celsius;
Temperatura(double celsius) {
this.celsius = celsius;
}
}
class TemperaturaValidada extends Temperatura {
TemperaturaValidada(double celsius) {
if (celsius < -273.15) { // antes de Java 25 esto no compilaba aquí
throw new IllegalArgumentException("Por debajo del cero absoluto");
}
super(celsius);
}
}
// JEP 506: Scoped Values, alternativa inmutable a ThreadLocal
final ScopedValue<String> USUARIO = ScopedValue.newInstance();
void procesar() {
IO.println("Procesando para " + USUARIO.get());
}
// JEP 512: archivo de código compacto y main de instancia, sin clase ni static
void main() {
List<String> lenguajes = List.of("Java", "Kotlin", "Scala"); // List viene del import module
IO.println("Lenguajes: " + lenguajes); // IO.println, nuevo en java.lang
IO.println(new TemperaturaValidada(21.5).celsius);
try {
new TemperaturaValidada(-300);
} catch (IllegalArgumentException e) {
IO.println("Error: " + e.getMessage());
}
ScopedValue.where(USUARIO, "ana").run(this::procesar);
IO.println("Fuera del ámbito, isBound = " + USUARIO.isBound());
}
Salida:
Lenguajes: [Java, Kotlin, Scala]
21.5
Error: Por debajo del cero absoluto
Procesando para ana
Fuera del ámbito, isBound = false
Qué aporta cada una
Archivos compactos y main de instancia (JEP 512)
Un programa ya no necesita public class ni public static void main(String[] args): basta con void main(). Los métodos y campos del archivo forman una clase implícita. La nueva clase java.lang.IO añade IO.println e IO.readln. Está pensado para aprender y para scripts; en una aplicación seguirás teniendo clases normales. Lo comparamos con el main clásico en el método main en Java.
import module (JEP 511)
import module java.base; importa de golpe todos los paquetes que exporta ese módulo (java.util, java.time, java.io…). En los archivos compactos java.base se importa automáticamente. Si dos módulos exportan clases con el mismo nombre, tendrás que desambiguar con un import concreto.
Sentencias antes de super(...) (JEP 513)
Hasta Java 24, super(...) o this(...) tenían que ser la primera línea del constructor, así que validar argumentos obligaba a métodos estáticos auxiliares. Ahora puedes validar o preparar valores antes, siempre que no uses this todavía. Más sobre constructores en this en Java.
Scoped Values (JEP 506)
Comparten un dato inmutable con todo el código que se ejecuta dentro de un ámbito (por ejemplo, el usuario de una petición) sin pasarlo como parámetro. Frente a ThreadLocal, el valor no se puede modificar, desaparece al salir del ámbito (no hay fugas por olvidar remove()) y funciona bien con miles de hilos virtuales.
Otras novedades de Java 25
| JEP | Qué cambia |
|---|---|
| 519 Compact Object Headers | Cabeceras de objeto más pequeñas: menos memoria (opcional, -XX:+UseCompactObjectHeaders) |
| 514 y 515 (AOT) | Preparación anticipada de clases para arrancar más rápido |
| 510 Key Derivation Function API | API estándar para derivar claves criptográficas |
| 521 Shenandoah generacional | Modo generacional del recolector Shenandoah como opción estándar |
| 503 | Se elimina el soporte para x86 de 32 bits |
Siguen en preview o incubadora, entre otras, la Vector API, la concurrencia estructurada y los patrones con tipos primitivos.
¿Merece la pena migrar?
Si estás en Java 21, Java 25 es la siguiente LTS y la migración suele ser directa; Spring Boot 4 lo soporta. Si sigues en Java 17 o anterior, salta directamente: ganas virtual threads, pattern matching para switch, records con patrones y todo lo de esta versión. Revisa antes que tus librerías y herramientas (Lombok, Mockito, plugins de Maven) estén al día. Tienes el salto anterior en Java 17 vs Java 21.
Preguntas frecuentes
¿Java 25 es LTS?
Sí. Las versiones LTS salen cada dos años: 17 (2021), 21 (2023) y 25 (2025).
¿Tengo que dejar de escribir public static void main?
No. La forma clásica sigue siendo válida y es la que verás en proyectos existentes.
¿Cómo pruebo Java 25?
Instala un JDK 25 de cualquier distribución (Temurin, Corretto, Oracle…) y ejecuta java Main.java. Si no quieres instalar nada, prueba fragmentos en el playground de Java.
Sigue aprendiendo
Las novedades del lenguaje desde Java 8 se repasan en el curso de Java intermedio, y la concurrencia moderna con hilos virtuales en el curso de Java avanzado.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.