Saltar a contenido

🧩 Keyword var en Java

var permite declarar variables locales sin escribir el tipo explícitamente, porque Java lo deduce automáticamente.

Pero cuidado:

var no convierte Java en un lenguaje dinámico. Java sigue siendo un lenguaje fuertemente tipado.

🧠 ¿Qué es var?

var es una palabra clave que permite que el compilador deduzca el tipo de una variable local a partir del valor que le asignamos.

Antes de var:

String nombre = "Ana";
int edad = 20;
ArrayList<String> nombres = new ArrayList<String>();

Con var:

var nombre = "Ana";
var edad = 20;
var nombres = new ArrayList<String>();

Java mira lo que hay a la derecha del = y deduce el tipo.

Código Tipo que deduce Java
var nombre = "Ana"; String
var edad = 20; int
var precio = 9.99; double
var activo = true; boolean
var lista = new ArrayList<String>(); ArrayList<String>

🔍 Ejemplo muy sencillo

public class Main {
    public static void main(String[] args) {
        var mensaje = "Hola mundo";
        var numero = 10;
        var decimal = 5.5;
        var correcto = true;

        System.out.println(mensaje);
        System.out.println(numero);
        System.out.println(decimal);
        System.out.println(correcto);
    }
}

Aunque no hemos escrito los tipos, Java los conoce perfectamente.

Este código sería equivalente a:

String mensaje = "Hola mundo";
int numero = 10;
double decimal = 5.5;
boolean correcto = true;

🚫 var no significa “cualquier tipo”

Este es el error más importante que hay que evitar.

En Java, una variable declarada con var sigue teniendo un tipo fijo.

var edad = 25;
edad = 30;      // Correcto
edad = "Ana";  // Error

¿Por qué da error?

Porque al escribir:

var edad = 25;

Java deduce que edad es de tipo int.

Por tanto, después no podemos guardar un String en esa variable.

🏠 var solo se puede usar en variables locales

var se usa principalmente dentro de métodos, constructores o bloques de código.

public void saludar() {
    var nombre = "Ana";
    System.out.println(nombre);
}

Eso es correcto porque nombre es una variable local.

❌ Dónde NO se puede usar var

❌ No se puede usar como atributo o campo de la clase

public class Persona {
    private var nombre = "Ana"; // Error
}

Los atributos de una clase deben tener el tipo escrito explícitamente:

public class Persona {
    private String nombre;
}

❌ No se puede usar como parámetro de un método

public void saludar(var nombre) { // Error
    System.out.println(nombre);
}

Debe escribirse así:

public void saludar(String nombre) {
    System.out.println(nombre);
}

❌ No se puede usar como tipo de retorno

public var obtenerNombre() { // Error
    return "Ana";
}

Debe escribirse así:

public String obtenerNombre() {
    return "Ana";
}

❌ No se puede declarar sin inicializar

var numero; // Error
numero = 10;

Java necesita ver el valor inicial para deducir el tipo.

Correcto:

var numero = 10;

❌ No se puede inicializar con null

var persona = null; // Error

Java no puede saber qué tipo queremos usar.

Correcto:

Persona persona = null;

❌ No se puede usar con inicializadores de arrays sin tipo

var numeros = {1, 2, 3}; // Error

Correcto:

var numeros = new int[]{1, 2, 3};

O también:

int[] numeros = {1, 2, 3};

✅ Cuándo SÍ tiene sentido usar var

var es útil cuando el tipo es muy evidente o cuando escribir el tipo completo hace el código más pesado.

✅ Con objetos recién creados

var lista = new ArrayList<String>();
var mapa = new HashMap<String, Integer>();
var persona = new Persona("Ana", 20);

Aquí el tipo se ve claramente en la parte derecha.

✅ En bucles for-each

var nombres = List.of("Ana", "Luis", "Marta");

for (var nombre : nombres) {
    System.out.println(nombre.toUpperCase());
}

Java deduce que nombre es un String.

✅ En bucles for normales

for (var i = 0; i < 5; i++) {
    System.out.println(i);
}

Java deduce que i es un int.

✅ Con tipos largos o incómodos

Sin var:

Map<String, List<Integer>> notasPorAlumno = new HashMap<String, List<Integer>>();

Con var:

var notasPorAlumno = new HashMap<String, List<Integer>>();

El código queda más corto sin perder información importante.

⚠️ Cuándo NO conviene usar var

var no siempre mejora el código.

A veces lo empeora porque oculta demasiado el tipo.

⚠️ Cuando el tipo no es evidente

var resultado = obtenerResultado();

Aquí no sabemos qué devuelve obtenerResultado().

¿Es un String?
¿Es un int?
¿Es un objeto?
¿Es una lista?

En este caso puede ser más claro escribir el tipo:

ResultadoOperacion resultado = obtenerResultado();

⚠️ Cuando el nombre de la variable no ayuda

Mal ejemplo:

var x = calcular();

No sabemos qué es x ni qué devuelve calcular().

Mejor:

var precioFinal = calcularPrecioFinal();

O incluso:

double precioFinal = calcularPrecioFinal();

🧪 var con colecciones

var se usa bastante con colecciones, pero hay que tener cuidado.

var nombres = new ArrayList<String>();
nombres.add("Ana");
nombres.add("Luis");

Java deduce:

ArrayList<String>

Por eso esto daría error:

nombres.add(25); // Error

La lista solo admite String.

💎 var y el operador diamante <>

Podemos combinar var con el operador diamante:

var nombres = new ArrayList<String>();

También se puede escribir:

var nombres = new ArrayList<>();

Pero hay que tener cuidado.

En este caso Java puede deducir algo demasiado genérico:

var lista = new ArrayList<>();

Aquí Java no tiene información suficiente sobre qué tipo de elementos queremos guardar.

Por eso, en clase es más recomendable escribir:

var lista = new ArrayList<String>();

O directamente:

ArrayList<String> lista = new ArrayList<>();

🧩 var con final

También podemos usar var con final.

final var nombre = "Ana";

Esto significa que la variable no podrá cambiar de valor.

final var edad = 20;
edad = 21; // Error

Sería equivalente a:

final int edad = 20;

🧬 var en lambdas

Desde Java 11, var también puede usarse en los parámetros de una expresión lambda.

(var nombre) -> nombre.toUpperCase()

Pero en cursos iniciales normalmente se usa así:

nombre -> nombre.toUpperCase()

El uso de var en lambdas es poco habitual en ejemplos sencillos.

Puede ser útil si queremos añadir anotaciones al parámetro:

(@NonNull var nombre) -> nombre.toUpperCase()

Pero esto no es necesario para empezar.

✅ Buenas prácticas

Usa var cuando:

  • El tipo se entiende claramente.
  • El código queda más limpio.
  • La parte derecha ya deja claro el tipo.
  • El nombre de la variable es descriptivo.

Evita var cuando:

  • El tipo no se entiende.
  • La variable tiene un nombre poco claro.
  • El método devuelve algo difícil de adivinar.
  • El código queda más confuso.

🧱 Ejemplo completo

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        var nombres = new ArrayList<String>();

        nombres.add("Ana");
        nombres.add("Luis");
        nombres.add("Marta");

        for (var nombre : nombres) {
            System.out.println(nombre.toUpperCase());
        }

        var total = nombres.size();
        System.out.println("Total: " + total);
    }
}

En este código:

var nombres = new ArrayList<String>();

Java deduce que nombres es un ArrayList<String>.

for (var nombre : nombres)

Java deduce que nombre es un String.

var total = nombres.size();

Java deduce que total es un int.

🏁 Idea final

var sirve para escribir menos, pero no para pensar menos.

La regla más sencilla es:

Usa var solo cuando el tipo se entienda fácilmente al leer el código.

Si al leer una línea tienes que preguntarte “¿qué tipo será esto?”, probablemente es mejor escribir el tipo explícitamente.