Java 25: Qué hay de nuevo y dónde aprenderlo en la práctica

Mientras otras plataformas esperan el lanzamiento oficial, nosotros ya hemos puesto en marcha nuestro curso. No esperamos a que todos discutan el nuevo Java — creamos el curso de inmediato 💪

Cuando lanzamos CodeGym en 2014, nuestro objetivo era simple — dar a las personas habilidades prácticas de programación, no presentaciones bonitas sobre "lo importante que es aprender los fundamentos". En más de 10 años, más de 2 millones de personas han tomado nuestros cursos. Ahora hemos creado el primer curso del mundo sobre Java 25, y quiero contarte qué hay de interesante allí.

Compact Source Files — Java para principiantes

El cambio más notable en Java 25 es la sintaxis simplificada para novatos. Ahora puedes escribir programas sin declarar explícitamente las clases:

// Anteriormente se necesitaba esto
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

// Ahora con esto es suficiente
void main() {
    IO.println("Hello, World!");
}

Si un archivo .java tiene métodos o campos fuera de una declaración explícita de clase, el compilador automáticamente crea una clase top-level implícita. Para quienes aprenden programación, esto reduce significativamente la barrera de entrada.

Instance Main Methods — sin static y String[]

Java 25 permite usar métodos de instancia como puntos de entrada del programa. Ya no es necesario explicar a los principiantes qué significa static:

void main() {
    // Método de instancia normal
    processData();
}

void processData() {
    IO.println("Procesando datos...");
}

Si una clase no tiene un método main estático adecuado, el lanzador de Java busca un método main de instancia y automáticamente crea una instancia de la clase.

java.lang.IO — Entrada/salida simple

La nueva clase java.lang.IO simplifica el trabajo con la consola. Ya no necesitas recordar System.out.println:

void main() {
    String name = IO.readln("Ingresa tu nombre: ");
    IO.println("¡Hola, " + name + "!");
}

La clase está en el paquete java.lang, por lo que está disponible sin import. Hay métodos para mostrar, ingresar y leer strings con prompt.

Flexible Constructor Bodies — Constructores flexibles

En Java 25 puedes realizar operaciones antes de llamar super() o this():

public class User {
    private final String email;
    private final String domain;
    
    public User(String email) {
        // Operaciones antes de la llamada super()
        this.domain = extractDomain(email);
        validateDomain(domain);
        
        super(); // Llamada al constructor Object
        
        this.email = email;
    }
    
    private String extractDomain(String email) {
        return email.substring(email.indexOf('@') + 1);
    }
}

Esto permite inicializar campos y realizar validación antes de crear el objeto, haciendo los constructores más naturales.

Module Import Declarations — Imports simplificados

JEP 511 introduce la capacidad de importar todos los paquetes de un módulo con una línea:

import module java.base;

// Ahora todas las clases de java.base están disponibles sin imports explícitos
void main() {
    var list = new ArrayList<String>();
    var file = new File("data.txt");
    var decimal = new BigDecimal("123.45");
}

Esto es especialmente útil al trabajar con módulos grandes donde necesitas muchas clases.

Stable Values — Constantes optimizadas

Nueva API para trabajar con valores inmutables que pueden inicializarse más tarde:

class Configuration {
    static final StableValue<String> DATABASE_URL = 
        StableValue.of(() -> loadFromConfig("db.url"));
        
    void connectToDatabase() {
        String url = DATABASE_URL.get(); // Inicialización perezosa
        // Conexión a la base de datos
    }
}

Los Stable Values ayudan a optimizar el tiempo de inicio de aplicaciones y proporcionan seguridad de hilos para la inicialización diferida.

Primitive Types in Patterns — Pattern Matching extendido

Java 25 extiende Pattern Matching a todos los tipos primitivos:

static String classify(Number n) {
    return switch (n) {
        case int i -> "Entero: " + i;
        case long l -> "Long: " + l;
        case double d -> "Double: " + d;
        case float f -> "Float: " + f;
        default -> "Tipo de número desconocido";
    };
}

Ahora puedes usar pattern matching con int, long, double, float y otros primitivos en expresiones switch e instanceof.

Compact Object Headers — Ahorro de memoria

En Java 25, los tamaños de los headers de objetos se reducen de 96-128 bits a 64 bits en arquitecturas de 64 bits:

// Cada objeto ahora ocupa menos memoria
List<String> list = new ArrayList<>(); // Menos overhead
Map<String, User> users = new HashMap<>(); // Ahorro en cada entrada

Esto es especialmente notable en aplicaciones con gran cantidad de objetos — microservicios y aplicaciones con heaps grandes.

Scoped Values — Contexto seguro

La versión final de Scoped Values permite pasar datos inmutables entre métodos e hilos:

private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

public void handleRequest(User user) {
    ScopedValue.where(CURRENT_USER, user)
        .run(() -> {
            processOrder();  // Dentro, acceso a user mediante CURRENT_USER.get()
            sendNotification();
            logActivity();
        });
}

A diferencia de ThreadLocal, los Scoped Values son más fáciles de usar, tienen menor overhead y funcionan mejor con hilos virtuales.

Mejoras en JFR — Mejor profiling

Java 25 mejora Java Flight Recorder con tres nuevas capacidades:

JFR Cooperative Sampling — recolección más segura de stack traces sin sesgo y con soporte para stack walking concurrente.

JFR Method Timing & Tracing — seguimiento del tiempo de ejecución de métodos específicos sin cambios en el código:

java -XX:StartFlightRecording:jdk.MethodTiming#methods=com.myapp.Service.* MyApp

CPU-Time Profiling on Linux — profiling preciso del tiempo de CPU utilizando capacidades del kernel de Linux.

API Key Derivation Functions

Nueva API para trabajar con funciones de derivación de claves (KDF):

// Ejemplo de uso de KDF para generar claves derivadas
KeyDerivationFunction kdf = KeyDerivationFunction.getInstance("PBKDF2WithHmacSHA256");
SecretKey derivedKey = kdf.deriveKey(password, salt, iterations, keyLength);

Esto es críticamente importante para aplicaciones criptográficas e implementación de almacenamiento seguro de contraseñas.

Por qué aprender Java 25

Java evoluciona rápidamente — nuevas versiones LTS salen cada 3 años. Quienes dominan las nuevas características primero obtienen una ventaja en el mercado laboral.

Java 25 es un release LTS con 5 años de soporte de Oracle. Las empresas migrarán a esta versión y buscarán desarrolladores que conozcan las nuevas capacidades del lenguaje.

El primer curso de Java 25

Cuando Oracle anunció la fecha de lanzamiento de Java 25, decidimos no esperar. CodeGym siempre ha estado adelante — fuimos los primeros en crear educación gamificada de programación, los primeros en crear tareas interactivas con verificación automática.

Ahora somos los primeros en darte la oportunidad de aprender Java 25 en la práctica. El curso incluye tanto novedades de Java 25 como características importantes de versiones anteriores — lambdas y Stream API de Java 8, módulos de Java 9, var de Java 10, Text Blocks de Java 13, Records de Java 14, Pattern Matching de Java 17, Virtual Threads de Java 21.

Qué hay en el curso:

• 325+ conferencias explicando cada novedad de Java 25
• 880+ tareas desde simple hasta nivel empresarial
• Mentor de IA que analiza código y da recomendaciones
• Integración con IntelliJ IDEA — aprende con herramientas profesionales
• Proyectos grandes — crea aplicaciones reales con nuevas tecnologías

La práctica — Fundamento del aprendizaje

A lo largo de años de enseñanza entendí una verdad simple: la teoría sin práctica es pérdida de tiempo. Puedes leer toda la documentación sobre Compact Source Files, pero hasta que no escribas varios programas con la nueva sintaxis, no sentirás la comodidad.

En el curso, cada novedad de Java 25 se refuerza inmediatamente con práctica. Aprende Flexible Constructor Bodies — escribe un sistema de inicialización de objetos seguro. Domina Scoped Values — crea una aplicación multihilo con paso de contexto. Entiende Module Import Declarations — simplifica la estructura de proyectos grandes.

Mentor de IA en el curso

La característica más interesante de nuestro curso es la IA que analiza el código de los estudiantes. No son consejos genéricos de ChatGPT, sino un sistema especializado que:

• Conoce el contexto de cada tarea del curso
• Analiza el estilo de programación
• Da recomendaciones personalizadas

Aprendizaje gamificado

La programación puede ser aburrida si la estudias mal. Por eso la educación de CodeGym está construida como un juego: niveles, logros, rankings.

En el curso de Java 25:

• Logros por resolver tareas de diferentes dificultades
• Ranking general de estudiantes
• Niveles como en un juego

Desde cero hasta listo para trabajar

El curso está construido para que incluso un principiante después de 65 niveles tenga conocimientos suficientes para trabajar en una empresa seria. El programa completo del curso incluye aprender Java 25 moderno, pero también cubre:

• Sintaxis moderna y nuevos operadores
• POO con nuevas capacidades del lenguaje
• Colecciones y Stream API
• Operaciones con archivos a través de API moderno
• Multithreading y gestión de hilos

Plugin para IntelliJ IDEA

Una de las características de CodeGym es el plugin para IntelliJ IDEA. Los estudiantes resuelven tareas directamente en un entorno de desarrollo profesional, con resaltado de sintaxis, autocompletado y debugger.

Verificación instantánea de soluciones

En CodeGym puedes resolver una tarea y conocer el resultado en segundos. El sistema automáticamente verifica el código, ejecuta pruebas y da feedback.

Para Java 25, el sistema de verificación entiende:

• Nueva sintaxis Compact Source Files
• Instance Main Methods
• Flexible Constructor Bodies
• Module Import Declarations

Por qué CodeGym para aprender Java 25

En más de 10 años de trabajo hemos entendido cómo enseñar programación eficazmente. Los reclutadores en empresas tech conocen CodeGym y frecuentemente preguntan en entrevistas: "¿Cuál es tu nivel en CodeGym?" No porque les paguemos por ello, sino porque saben — si alguien llegó al nivel 40, sabe programar, no solo memorizar sintaxis.

El curso de Java 25 es la evolución de nuestra metodología. El mismo enfoque práctico, pero con las tecnologías más modernas.

Empieza a aprender ahora

Java 25 ya salió y puedes aprenderlo ahora — mientras los competidores leen las release notes. Nuestro curso contiene todas las innovaciones con ejemplos prácticos.

65 niveles de tareas prácticas, mentor de IA, integración con herramientas profesionales — todo para que domines Java moderno rápida y eficazmente.

Conviértete en un desarrollador Java listo para 2025.