Java Academy · Lección

Cuándo var mejora la legibilidad

Usos adecuados e inadecuados de var

Cuándo var mejora la legibilidad es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

var es una decisión de estilo

var es opcional. Utilizado correctamente, hace que el código sea más limpio; utilizado sin cuidado, oculta información importante. Los buenos desarrolladores aprenden cuándo recurrir a él.

Bien: el lado derecho es evidente

Cuando el inicializador muestra claramente el tipo, var elimina ruido sin perder claridad.

public class Main {
    public static void main(String[] args) {
        var name = "Alice";
        var customers = new java.util.ArrayList<String>();
        customers.add(name);
        System.out.println(customers);
    }
}

Mal: tipo oculto en un método

Cuando el tipo no es evidente a partir de la llamada, var puede perjudicar la legibilidad. Aquí no se puede saber de un vistazo qué devuelve parse.

public class Main {
    static int parse(String s) {
        return Integer.parseInt(s);
    }
    public static void main(String[] args) {
        var result = parse("123");
        System.out.println(result + 1);
    }
}

Bien: tipos genéricos largos

En declaraciones genéricas extensas, var resulta claramente ventajoso porque el tipo ya aparece en el inicializador.

import java.util.HashMap;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        var groups = new HashMap<String, List<Integer>>();
        groups.put("odd", List.of(1, 3, 5));
        System.out.println(groups);
    }
}

Mal: literales numéricos ambiguos

var puede ocultar si pretendía utilizar int, long o double. Si el tipo numérico exacto es importante, prefiera un tipo explícito.

public class Main {
    public static void main(String[] args) {
        var x = 100;
        long big = x * 1000000L;
        System.out.println(big);
    }
}

Utilice nombres significativos

Con var, el nombre de la variable adquiere más importancia. Elija nombres descriptivos para que los lectores entiendan la intención incluso sin conocer el tipo.

public class Main {
    public static void main(String[] args) {
        var customerCount = 5;
        var welcomeMessage = "Welcome";
        System.out.println(welcomeMessage + " (" + customerCount + ")");
    }
}

Bien: variables de bucle

En los bucles for mejorados, el tipo del elemento se deduce claramente de la colección, por lo que var resulta fácil de leer.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        var words = List.of("sky", "sea", "sun");
        for (var word : words) {
            System.out.println(word.length() + ": " + word);
        }
    }
}

Mal: llamadas encadenadas

Cuando un valor procede de una cadena larga de llamadas, el tipo resultante puede ser inesperado. Un tipo explícito documenta el resultado para el lector.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        var count = List.of(1, 2, 3, 4).stream().filter(n -> n > 2).count();
        System.out.println(count);
    }
}

Coherencia dentro de un archivo

Elija un estilo coherente. Mezclar var y tipos explícitos al azar en código similar puede resultar confuso. Busque la previsibilidad.

public class Main {
    public static void main(String[] args) {
        var first = "Jane";
        var last = "Doe";
        var full = first + " " + last;
        System.out.println(full);
    }
}

El operador diamante ya ayuda

Con var, puede conservar el argumento de tipo en el lado derecho. Esto es más claro que confiar únicamente en el operador diamante cuando se elimina el tipo del lado izquierdo.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var names = new ArrayList<String>();
        names.add("Sam");
        System.out.println(names.get(0));
    }
}

Regla práctica

Utilice var cuando el inicializador haga evidente el tipo y el nombre sea significativo. Evítelo cuando el tipo sea importante pero no resulte visible. El objetivo es facilitar la lectura a la siguiente persona.

public class Main {
    public static void main(String[] args) {
        var greeting = "Readable code wins";
        System.out.println(greeting);
    }
}

Comprobación rápida

¿En qué situación se utiliza var de la mejor manera para mejorar la legibilidad?

Resumen

Ha aprendido cuándo resulta útil var:

Bien: inicializadores evidentes, tipos genéricos largos y variables de bucle claras
Mal: resultados de métodos ocultos, tipos numéricos ambiguos y cadenas complejas de llamadas
Utilice nombres significativos para compensar la ausencia del tipo
Mantenga la coherencia dentro de un archivo
Optimice el código para la siguiente persona que lo lea

Preguntas frecuentes

¿La lección «Cuándo var mejora la legibilidad» es gratis?

Sí — el texto completo de «Cuándo var mejora la legibilidad» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cuándo var mejora la legibilidad»?

Usos adecuados e inadecuados de var Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Cuándo var mejora la legibilidad»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy