Variables en Java: declaración, asignación y ámbito explicados

Qué es una variable

Una variable es una caja con nombre que guarda un valor. En Java toda variable tiene un tipo fijo - decidido cuando la declaras - y ese tipo nunca cambia. Esto es lo que hace que Java sea de tipado estático: el compilador conoce el tipo de cada variable antes de que el programa se ejecute, y se negará a compilar código que ponga un valor del tipo equivocado en una caja.

Una declaración tiene tres partes: el tipo, el nombre y (normalmente) un valor inicial.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Lee int age = 30; como "crea un int llamado age y pon 30 dentro". El punto y coma termina la sentencia, igual que la página de comentarios mostró que hacen todas las sentencias.

Declarar ahora, asignar después

Puedes separar una declaración de su primera asignación. El tipo aparece una sola vez, en la declaración; después asignas usando solo el nombre y =:

public class Main {
    public static void main(String[] args) {
        int score;        // declarada, todavía sin valor
        score = 95;       // asignada ahora
        score = 100;      // reasignada - perfectamente válido

        System.out.println(score);
    }
}

Una regla que pilla a los principiantes: debes asignar un valor a una variable local antes de leerla. El compilador lleva la cuenta de esto y rechaza el código que lee una variable local sin inicializar:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

Esto es una característica, no una molestia: detecta toda una clase de errores antes de que el programa llegue a ejecutarse.

Reglas y convenciones de nombrado

Java impone unas pocas reglas estrictas y luego añade convenciones por encima. Las reglas: un nombre puede contener letras, dígitos, _ y $, pero no puede empezar por un dígito, no puede ser una palabra reservada (como int o class) y distingue entre mayúsculas y minúsculas (age y Age son dos variables distintas).

Las convenciones que todo el mundo sigue:

• Las variables y los métodos usan camelCase: firstName, totalScore.
• Las constantes usan UPPER_SNAKE_CASE: MAX_USERS.
• Los nombres deben describir el valor: count, no c; userEmail, no x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Los nombres claros no son decoración: son la forma en que tu yo futuro lee el código. totalPrice = itemCount * pricePerItem se explica solo de un modo que t = c * p nunca conseguirá.

Seguridad de tipos: la caja conserva su tipo

Como el tipo queda bloqueado en la declaración, no puedes meter un valor del tipo equivocado en una variable. Esto detecta los errores en tiempo de compilación:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

Asignar entre tipos numéricos sigue las reglas de ampliación (widening): un tipo más pequeño fluye automáticamente hacia uno más grande, pero no al revés. Lo veremos en detalle en las páginas de tipos de datos y conversión de tipos; por ahora basta con saber que el compilador está vigilando.

La palabra clave var

Desde Java 10 puedes escribir var en lugar del tipo y dejar que el compilador lo infiera a partir del valor de la derecha:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // inferido como String
        var count = 5;                 // inferido como int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var no es tipado dinámico: name es tan String como si hubieras escrito String name, y sigues sin poder asignarle más tarde un int. Solo ahorra escritura. El truco: var necesita un inicializador del que inferir, así que var x; es ilegal, y solo funciona con variables locales, nunca con campos, parámetros de método ni tipos de retorno. Úsalo cuando el tipo sea obvio por el lado derecho; escribe el tipo explícito cuando aporte claridad.

Constantes con final

Cuando un valor no debe cambiar nunca después de fijarse, márcalo como final. Cualquier intento de reasignarlo se convierte en un error de compilación:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // no compilaría - no se puede reasignar una variable final
    }
}

final comunica la intención ("este es un valor fijo") y deja que el compilador lo proteja por ti. Recurre a él siempre que un valor sea conceptualmente una constante - tasas, límites, claves de configuración - para que una reasignación accidental se detecte en lugar de colarse silenciosamente como un error.

Ámbito de las variables

Una variable existe solo dentro del bloque - el { ... } - donde se declara, y muere en la llave de cierre. Esto es su ámbito. Una variable declarada dentro de un bucle o de un bloque if es invisible fuera de él:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' vive solo dentro del cuerpo de este bucle
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // error - 'square' está fuera de ámbito aquí
    }
}

Tanto i como square pertenecen al bucle y desaparecen cuando termina; total se declara en el bloque exterior, así que sobrevive. La lección práctica: declara cada variable en el bloque más pequeño que la necesite. Un ámbito reducido significa menos nombres compitiendo por tu atención y menos posibilidades de usar mal un valor lejos de donde se estableció.

Siguiente: tipos de datos

Cada variable de esta página empezó con un tipo - int, double, String, boolean. La siguiente página desglosa en detalle los tipos de datos de Java: los ocho primitivos, el tamaño de cada uno, la diferencia entre primitivos y objetos, y qué tipo elegir en cada caso.