Artículo

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 module para importar un módulo entero (JEP 511), sentencias antes de super(...) en constructores (JEP 513) y Scoped Values como alternativa a ThreadLocal (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

JEPQué cambia
519 Compact Object HeadersCabeceras 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 APIAPI estándar para derivar claves criptográficas
521 Shenandoah generacionalModo generacional del recolector Shenandoah como opción estándar
503Se 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.

java 25 novedades java lts scoped values jep java

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.

Compartir artículo