Variables en Java

Una variable es una ubicación de almacenamiento con nombre y tipo fijo. Una vez declarada, el tipo no puede cambiar, pero el valor que contiene generalmente sí puede. El tipo controla cuánta memoria usa la variable, qué valores son válidos y qué operaciones permite el compilador. Este capítulo explica cómo declarar variables, cómo inicializarlas, los cuatro tipos que distingue Java y las reglas sobre final, var y el ámbito.

Declarar una variable

La forma básica es un tipo seguido de un nombre y un punto y coma:

type name;

Por ejemplo, int score; reserva un espacio con forma de int llamado score. El tipo es uno de los tipos integrados de Java (int, double, boolean, char, …) o cualquier clase o interfaz — consulta Java Data Types para la lista completa.

Las declaraciones más simples:

int score;
String name;
boolean ready;

Estas reservan almacenamiento; aún no asignan ningún valor.

Inicializar

Para asignar un valor, usa =:

int score = 0;
String name = "Ada";
boolean ready = true;

También puedes declarar y asignar por separado:

int score;
score = 0;

O declarar varias variables del mismo tipo a la vez:

int x = 1, y = 2, z = 3;

(Una por línea suele ser más claro.)

Las variables locales deben asignarse antes de usarse

Una variable local — declarada dentro de un método — no tiene valor predeterminado. El compilador no permite leerla hasta que se le haya asignado algo:

public static void main(String[] args) {
    int x;
    // System.out.println(x); // compile error: variable x might not have been initialized
    x = 5;
    System.out.println(x);    // OK
}

Esta es una de las características de seguridad más útiles de Java — detecta una categoría de errores que otros lenguajes dejan pasar.

Los cuatro tipos de variables

Java distingue cuatro categorías de variables según dónde se declaran:

1. Variables locales — declaradas dentro de un método o bloque. Viven solo mientras el método se ejecuta. Sin valor predeterminado. Deben inicializarse antes de usarse.
2. Variables de instancia (campos) — declaradas dentro de una clase pero fuera de cualquier método. Una copia por objeto. Por defecto son 0 / 0.0 / false / null.
3. Variables estáticas (variables de clase) — declaradas con la palabra clave static. Una copia compartida por cada instancia de la clase. Por defecto son 0 / false / null.
4. Parámetros — declarados en la firma de un método; reciben el valor pasado por el llamador.

public class Counter {
    static int totalCounters;   // static (class) variable
    int count;                  // instance variable

    public void add(int delta) { // delta is a parameter
        int doubled = delta * 2; // doubled is a local variable
        count += doubled;
    }
}

Volverás a encontrar las variables de instancia y estáticas en los capítulos de POO; por ahora, la mayoría de las variables que escribas serán locales.

final — asignar una sola vez

Añadir final como prefijo a una declaración convierte la variable en un enlace de un solo uso. Tras la primera asignación, no puede cambiar:

final int MAX_RETRIES = 3;
// MAX_RETRIES = 4; // compile error: cannot assign a value to final variable

Usar final para las cosas que no deben cambiar hace explícita la intención y permite que el compilador detecte reasignaciones accidentales. Por convención, los campos final que contienen constantes fijas se nombran en UPPER_SNAKE_CASE (consulta Java Naming Conventions).

Ten en cuenta que final congela el enlace, no el objeto al que apunta. Una referencia final no puede reasignarse, pero el objeto al que apunta sí puede modificarse:

final int[] nums = {1, 2, 3};
nums[0] = 99;        // OK — the array contents change
// nums = new int[5]; // compile error — the reference is final

var — dejar que el compilador elija el tipo

Desde Java 10, puedes escribir var en lugar de un tipo para variables locales cuando el lado derecho hace obvio el tipo:

var name = "Ada";          // inferred as String
var score = 0;             // inferred as int
var values = new int[10];  // inferred as int[]

var no es tipado dinámico — la variable sigue teniendo un tipo fijo, el compilador simplemente lo deduce por ti. Restricciones:

• Solo para variables locales.
• El lado derecho debe estar presente (var x; es ilegal).
• No está permitido para parámetros, variables de instancia ni variables estáticas.

var es más útil cuando el nombre del tipo es largo u obvio por el contexto:

var orders = new HashMap<String, List<Order>>();

Usa declaraciones de tipo ordinarias cuando el tipo inferido no sea obvio para quien lee el código.

Ámbito

Una variable está en ámbito — visible — desde su declaración hasta el final del bloque que la contiene:

public static void main(String[] args) {
    int outer = 1;

    if (outer > 0) {
        int inner = 2;
        System.out.println(outer + inner);   // both visible
    }

    // System.out.println(inner);   // compile error: inner is out of scope
}

No puedes declarar dos variables locales con el mismo nombre en ámbitos superpuestos — pero un nombre sí puede reutilizarse en dos bloques separados que no se solapen:

for (int i = 0; i < 3; i++) { /* i lives here */ }
for (int i = 0; i < 5; i++) { /* a new, separate i */ }  // fine

Mantener pequeños los ámbitos de las variables es una buena práctica: declara cada variable lo más cerca posible del lugar donde se usa por primera vez.

Un ejemplo funcional

Qué sigue

Java Naming Conventions cubre las reglas estándar que sigue todo código Java para los nombres de clases, métodos, variables y constantes.

Práctica