Java 25 ya está aquí, y no es una versión cualquiera: es la nueva LTS (Long-Term Support). Pero, ¿cuáles son las características que realmente te harán la vida más fácil, tu código más limpio y tus aplicaciones más robustas? Te contamos las cuatro joyas que trae y que debes conocer.
👆👆👆 Suscríbete a nuestro podcast. Y mejor aún, a nuestro boletín mensual: todo cosas útiles que no encontrarás en otro lado, una vez al mes.
La semana pasada salió la versión 25 de Java con 16 JEPs (o propuestas de mejora) en total. Pero para no abrumar, he seleccionado las 4 que creo que tienen un impacto más directo y positivo en nuestro día a día como desarrolladores, desde el que empieza hasta el que ya tiene experiencia. Y además me quedo tan solo con las que no son experimentales o en vista previa.
El resto las puedes consultar en las notas de Java 25 del OpenJDK.
La primera cosa importante que debes saber de Java 25 es que es una LTS: una versión Long-Term Support o con soporte a largo plazo. O sea, es una de esas versiones robustas en las que las empresas confían durante años para sus aplicaciones en producción, por lo que va a tener una gran adopción. La anterior LTS fue la 21, hace 2 años. La 25 que acaba de salir estará soportada hasta 2030.
Por cierto, nuestro curso online de Java está actualizado ya a la versión 25 😉
Dicho esto, vamos con la primera joyita que trae...
Joya nº 1 de Java 25: Escribir código sin "ceremonias" (JEP 512)
Si has hecho cualquier cosa con Java, hasta un "hola mundo" sabes que siempre había que crear una clase y un método main con varios argumentos:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
No parece mucho, pero esto para alguien que empieza, es una barrera. Son muchos conceptos que asimilar solo para poder imprimir un "Hola, Mundo": clases y objetos, métodos, argumentos y tipos, espacios de nombres...
Pues bien, la primera joya de Java 25 ataca directamente ese problema. Se llama "Ficheros de código fuente compactos", o JEP 512, y sigue la estela de otros lenguajes como C# (que se adaptó hace poco), Node.js o Python que lo hacen mucho más fácil.
¿Qué significa esto en la práctica? Que ahora puedes escribir un programa Java así de simple:
void main() { System.out.println("Hola desde Java 25!"); }
Y ya está. Funciona. Sin necesidad de declarar una clase explícitamente.
Es un cambio pequeño, pero con un impacto grande. Facilita muchísimo el aprendizaje de Java y es fantástico para crear pequeños scripts o prototipos rápidos. Se reduce el código repetitivo y la barrera de entrada para los nuevos desarrolladores es mucho más baja.
Joya nº 2 de Java 25: Constructores más limpios y seguros (JEP 513)
A todos nos ha pasado. Estás creando una clase que hereda de otra y tienes que escribir un constructor. La primera regla que te graban a fuego es: la llamada a super() debe ser la primera línea. Siempre.
Esto, que parece una norma de seguridad, muchas veces nos obliga a escribir código un poco raro. Por ejemplo, si necesitas validar un argumento antes de pasárselo al constructor del padre, tenías que crear un método estático auxiliar o duplicar la lógica. Era un fastidio.
La segunda joya de Java 25 se llama "Cuerpos de Constructor Flexibles" (JEP 513), y viene a ayudarnos con este problemilla.
Ahora, puedes poner código antes de la llamada a super(). Mira qué diferencia:
class Empleado extends Persona {
final String nombre;
Empleado(String nombre, int edad) {
// ¡Esto ahora es posible!
if (edad < 18) {
throw new IllegalArgumentException("El empleado debe ser mayor de edad");
}
super(edad); // La llamada ya no tiene que ser la primera línea
this.nombre = nombre;
}
}
Este cambio hace que el código sea más natural y seguro. Permite validar los datos de entrada justo al principio, siguiendo el principio de "fallar rápido". Es un pequeño cambio que resuelve una molestia histórica y nos ayuda a escribir clases más robustas.
En este artículo de cuando salió Java 24 y esto estaba en preview, tienes un ejemplo más completo del antes y el después.
Joya nº 3: Adiós a ThreadLocal, hola Scoped Values (JEP 506)
Ahora hablemos de concurrencia. Imagina que tienes que pasar un dato, como el ID del usuario que ha iniciado sesión o cualquier otra cosa, a través de muchas capas de tu aplicación: del controlador al servicio, del servicio al repositorio...
La solución clásica era usar variables locales al hilo actual, con la clase ThreadLocal, que lleva danzando por ahí desde Java 1.2. Funciona, pero tiene sus problemas, sobre todo con los hilos virtuales: fugas de memoria, código difícil de seguir... Era una herramienta potente, pero un poco peligrosa.
Ahora Java 25 presenta la versión definitiva de los Scoped Values (JEP 506).
Piensa en ellos como una forma moderna y segura de compartir datos inmutables dentro de un hilo o incluso entre hilos hijos. Se diseñaron específicamente para funcionar a la perfección con los hilos virtuales.
Su uso es muy sencillo:
// Declaras un valor con ámbito, inmutable.
public static final ScopedValue<String> USUARIO_ACTUAL = ScopedValue.newInstance();
// Y luego, lo usas así:
ScopedValue.where(USUARIO_ACTUAL, "Ana").run(() -> {
// Dentro de este bloque, cualquier llamada a USUARIO_ACTUAL.get() devolverá "Ana".
miServicio.hacerAlgo();
});
El valor solo existe dentro de ese bloque run. Es limpio, eficiente y mucho más fácil de razonar que ThreadLocal. Es la herramienta perfecta para pasar contexto en aplicaciones modernas. No quiere decir que las variables locales de hilo vayan a desaparecer, que sería una locura, pero esto es mucho mejor y es lo que se recomienda utilizar a partir de ahora.
Joya nº 4: Seguridad preparada para el futuro (JEP 510)
Y para nuestra última joya, vamos a hablar de algo que a veces dejamos de lado, pero es fundamental: la seguridad.
Java 25 da por finalizada una nueva API muy importante: la API de Función de Derivación de Claves (KDF, por sus siglas en inglés), recogida en la JEP 510.
Suena complejo, pero la idea es muy útil. Las KDF son algoritmos que nos permiten derivar claves de cifrado adicionales a partir de una clave secreta y otros datos. Un ejemplo típico es generar una clave de cifrado fuerte y segura a partir de una contraseña que ha escrito un usuario. Va mucho más allá de añadirle el típico "salt", ya que se trata de algoritmos seguros y poscuánticos.
Tener una API estándar en el JDK para esto es una gran ventaja. Ya no dependemos de librerías de terceros para implementar algoritmos robustos como PBKDF2. Pero lo más interesante es la visión a futuro: esta API es un pilar fundamental para la transición hacia la criptografía resistente a la computación cuántica. Java se está preparando hoy para las amenazas de seguridad del mañana, y eso da mucha tranquilidad si nos importa crear aplicaciones seguras.
Conclusiones
Y ahí lo tienes. Cuatro joyas de Java 25 que nos hacen la vida más fácil y las aplicaciones más robustas y seguras.
Java 25 es una versión sólida, con soporte a largo plazo y que demuestra que la plataforma sigue evolucionando de forma inteligente.
Si quieres aprender bien y en serio Java, .NET, Front-End, bases de datos y muchas otras cosas, en campusMVP.es tenemos los mejores cursos online en español que te ayudarán a estar siempre al día. Y que, si los paga tu empresa en España, le pueden salir gratis.