Variables de Java explicadas: tipos, alcance, var, final y errores comunes

1. ¿Qué son las “Variables” en Java?

Cuando comienzas a aprender Java, uno de los primeros conceptos importantes que encuentras es la “variable”.
En resumen, una variable es un contenedor utilizado para almacenar temporalmente valores (datos) dentro de un programa para que puedas reutilizarlos tantas veces como sea necesario.

Sin embargo, en Java, te atascarás rápidamente si memorizas las variables solo como “cajas”.
Eso se debe a que las variables en Java se manejan junto con un “tipo” (el tipo de datos).

En esta sección, organizaremos el rol de las variables y la forma de pensar específica de Java (la importancia de los tipos) para principiantes.

1.1 Qué puedes hacer con las variables (Almacenar valores y reutilizarlos)

Con las variables, un programa puede pasar de “cálculos de una sola vez” a “procesamiento significativo”.

Por ejemplo, puedes escribir números directamente así:

System.out.println(100 + 20);

Esto funciona, pero los valores no tienen significado, por lo que quien lea el código más tarde (incluyéndote a ti mismo en el futuro) tendrá dificultades.
No sabrás “¿Qué es 100?” o “¿Qué es 20?”.

Al usar variables, puedes dar significado a los valores.

int price = 100;
int tax = 20;
System.out.println(price + tax);

Usar variables de esta manera proporciona los siguientes beneficios:

• Más fácil de entender la intención (nombres como price y tax transmiten significado)
• Puedes reutilizar valores repetidamente (no necesitas escribir el mismo valor una y otra vez)
• Más fácil de cambiar después (si la tasa de impuestos cambia, solo cambias el valor de la variable)
• Puedes mantener resultados intermedios (divide la lógica compleja en pasos más pequeños)

Especialmente como principiante, está bien pensar en “variables = nombrar valores”.
Sin embargo, en Java, el siguiente concepto—“tipos”—siempre viene como un conjunto.

1.2 Las variables en Java se usan con “Tipos” (Seguridad de tipos)

En Java, las variables se crean generalmente en la siguiente forma:

type variableName = value;

Ejemplo:

int age = 20;
String name = "Sagawa";

El punto clave aquí es el tipo.

• int es un entero (p. ej., 20, 100, -5)
• String es una cadena (p. ej., «Hello», «Java»)

En Java, cuando creas una variable, declaras explícitamente “qué tipo de valor puede contener esta variable”.
Debido a este sistema, Java tiene fortalezas como las siguientes.

¿Qué significa “Type-Safe”?

Porque especificas tipos, Java puede detenerte cuando intentas poner el tipo equivocado de valor en una variable.

Por ejemplo, si intentas poner una cadena en una variable int, obtendrás un error en tiempo de compilación.

int age = "20"; // This is an error

Esto no es inconveniente—de hecho, es útil.
En lugar de “romperse después de ejecutar el programa”, puedes “detectar errores antes de ejecutarlo”.

Los principiantes a veces sienten que “Java tiene muchos errores” por esto, pero si cambias tu perspectiva:

• Java encuentra desajustes de tipos temprano
• Cuanto más grande sea el proyecto, más ayudan los tipos a reducir accidentes

Esta idea—“los tipos y las variables vienen como un conjunto”—es una de las bases más fundamentales de Java.

Nota: Incluso con “Variables”, hay “Valores” y “Referencias”

Las variables en Java se manejan ampliamente de dos maneras:

• Tipos primitivos : manejan el valor en sí (p. ej., int , double , boolean )
• Tipos de referencia : manejan no el valor en sí, sino la ubicación (referencia) donde se almacena el valor (p. ej., String , arrays, clases)

No profundizaremos aquí, pero este es un punto común de confusión para principiantes, por lo que vale la pena mencionarlo de antemano.

Por ejemplo, String es un tipo de referencia.
Puede parecer que estás “almacenando una cadena”, pero estrictamente hablando, estás sosteniendo “una referencia a un objeto de cadena”.

Esta diferencia también se relaciona con temas que aprenderás más adelante, como “== vs equals” y “cómo se comporta final”.

2. Conceptos básicos de variables: La diferencia entre declaración, asignación e inicialización

Para entender correctamente las variables en Java,
es importante organizar las diferencias entre “declaración”, “asignación” e “inicialización”.

Los principiantes a menudo usan estas tres palabras como si significaran lo mismo,
pero en realidad, tienen roles claramente diferentes.

Si mantienes esta ambigüedad,
es más probable que caigas en el estado de
“No sé por qué es un error” o “No sé por qué no puedo usarlo.”

2.1 Declaración: Preparándote para Usar una Variable

Declaración significa decirle a Java:
“Voy a usar una variable con este nombre” y “su tipo es este”.

La declaración más básica se ve así:

int count;

En este punto, solo han sucedido estas dos cosas:

• Crear una variable llamada count
• Decidir que su tipo es int (un entero)

Aún no se ha almacenado ningún valor.

Esta es una concepción errónea común entre principiantes:
declarar una variable por sí sola no la hace “lista para usar”.

2.2 Asignación: Poniendo un Valor en una Variable

Asignación significa poner un valor en una variable que ya ha sido declarada.

count = 10;

Este = no significa “igual” en matemáticas.
Significa poner el valor de la derecha en la variable de la izquierda.

Entonces, el flujo se convierte en:

int count;   // declaration
count = 10;  // assignment

Esa es la idea.

Nota: No Puedes Asignar a una Variable No Declarada

El siguiente código resulta en un error:

count = 10; // Error: count has not been declared

En Java, el orden debe ser declaración → asignación.

2.3 Inicialización: Asignando un Valor al Tiempo de la Declaración

Inicialización significa hacer la declaración y la asignación al mismo tiempo.

int count = 10;

Esto es semánticamente lo mismo que estas dos líneas:

int count;
count = 10;

En Java—tanto en el trabajo real como en el aprendizaje—
en la mayoría de los casos, está bien asumir que usarás “inicialización.”

Eso se debe a que tiene los siguientes beneficios:

• La variable se vuelve usable en el momento en que se crea
• Previene errores causados por variables no inicializadas
• El código se vuelve más fácil de leer

Entonces, como principiante,
se recomienda formar el hábito de
“inicializar las variables al tiempo que las declaras”.

2.4 Por Qué No Puedes Usar una Variable Solo con una Declaración (Reglas de Variables Locales)

En Java, hay reglas muy estrictas para las variables locales (variables dentro de métodos).
Java es particularmente estricto en esto.

El siguiente código resulta en un error de compilación:

int number;
System.out.println(number); // Error

La razón es clara:

Las variables locales no pueden usarse a menos que estén inicializadas

Esa regla existe.

Java trata el estado “no sabemos qué hay dentro de number” como
un estado peligroso y lo detiene como un error antes de la ejecución.

Esto puede parecer estricto para los principiantes, pero en el desarrollo a gran escala,
es un mecanismo de seguridad muy importante.

2.5 Declarando Múltiples Variables a la Vez (Con Precaución)

En Java, puedes declarar múltiples variables del mismo tipo juntas.

int x, y, z;

También puedes escribirlo así:

int a = 1, b = 2, c = 3;

Esto es sintácticamente correcto, pero puede reducir la legibilidad, así que ten cuidado.

Especialmente para principiantes y desarrollo en equipo, es más seguro escribir:

int a = 1;
int b = 2;
int c = 3;

como una variable por línea.

2.6 Resumen de la Sección

Puntos clave para recordar de esta sección:

• Declaración : decidir el nombre y el tipo de la variable
• Asignación : poner un valor en una variable
• Inicialización : declarar y asignar al mismo tiempo
• Las variables locales no pueden usarse a menos que estén inicializadas
• Como principiante, usa “declaración + inicialización” como predeterminado

3. Entendiendo los “Tipos” de Variable (Tipos Primitivos y Tipos de Referencia)

Al trabajar con variables de Java, no puedes evitar entender los tipos.
Lo que a menudo confunde a los principiantes es:

• Por qué hay tantos tipos
• Por qué los números tienen tanto int como double
• Cómo String difiere de los tipos numéricos

.En esta sección, organizaremos los tipos de Java desde dos perspectivas:
«tipos primitivos» y «tipos de referencia».

3.1 Los tipos de Java se dividen en dos grandes categorías

Los tipos de variables en Java pueden clasificarse ampliamente en las siguientes dos categorías:

1. Tipos primitivos
2. Tipos de referencia

Una vez que comprendas esta clasificación, los temas que aprenderás más adelante —como «== vs equals», «cómo se comporta final» y «cómo funciona la memoria»— serán mucho más fáciles de entender.

3.2 ¿Qué son los tipos primitivos? (Tipos que almacenan el valor directamente)

Los tipos primitivos son tipos que almacenan directamente el valor en sí.

Veamos algunos tipos primitivos comunes:

int count = 10;
double price = 19.99;
boolean isActive = true;

Estas variables guardan
el «valor en sí» dentro de la variable.

Tipos primitivos de uso frecuente

Como principiante, basta con dominar primero int, double y boolean.

3.3 Características y advertencias de los tipos primitivos

Los tipos primitivos presentan las siguientes características:

• Almacenan el valor en sí
• Son rápidos de procesar
• No puedes asignar null
• Su tamaño es fijo

Por ejemplo, en el código siguiente,
a y b contienen valores completamente independientes.

int a = 5;
int b = a;
b = 10;

En este caso:

• a sigue siendo 5
• b cambia a 10

Ese es el resultado.

Esto ocurre porque el valor en sí fue copiado.

3.4 ¿Qué son los tipos de referencia? (Tipos que manejan la ubicación del valor)

Por otro lado, los tipos de referencia
son tipos que manejan no el valor en sí, sino la ubicación (referencia) donde el valor existe.

Los tipos de referencia típicos incluyen:

String name = "Java";
int[] numbers = {1, 2, 3};

• String
• Arreglos
• Clases
• Interfaces
• Colecciones como List / Map

Todos estos son tipos de referencia.

Comprendiendo los tipos de referencia con una imagen

Una variable de tipo referencia contiene:

• no el objeto real en sí, sino
• una “dirección” que apunta a donde está almacenado el objeto real

Ese es el modelo mental.

3.5 ¿Qué ocurre al asignar tipos de referencia?

Observa el siguiente código:

String a = "Hello";
String b = a;
b = "World";

En este caso:

• a es «Hello»
• b es «World»

Ese es el resultado.

Si solo miras esto, podrías pensar:
«¿No es lo mismo que los tipos primitivos?»

¿Y el siguiente ejemplo?

int[] array1 = {1, 2, 3};
int[] array2 = array1;

array2[0] = 100;

El resultado es:

• array1[0] → 100
• array2[0] → 100

Esto ocurre porque array1 y array2 hacen referencia al mismo arreglo.

Con los tipos de referencia:

• Asignar variables puede hacer que “apunten al mismo objeto real”
• Cambiar el contenido puede afectar a todo lo que lo referencia

Esa es la característica clave.

3.6 Puntos de confusión comunes para principiantes

Resumamos los obstáculos habituales:

• Tipos primitivos → el valor se copia
• Tipos de referencia → la referencia (ubicación) se copia

Esta diferencia está estrechamente relacionada con los siguientes temas:

• La diferencia entre == y .equals()
• Qué ocurre cuando usas final
• Cómo pasar valores como argumentos de método afecta al alcance y al comportamiento

Por ahora, basta con recordar esto:
los tipos de referencia a veces pueden compartir el mismo objeto real.

3.7 Resumen de la sección

• Los tipos de Java se dividen en tipos primitivos y tipos de referencia
• Los tipos primitivos manejan «el valor en sí»
• Los tipos de referencia manejan «la ubicación (referencia) del valor»
• Con los tipos de referencia, la asignación y los cambios pueden afectar a otras variables

4. Tipos de variables (dónde viven) y alcance (dónde son válidas)

En Java, las variables no solo difieren por su «tipo».
Su comportamiento también cambia según dónde se declaran (dónde viven).

Si no comprendes esta diferencia, puedes confundirte con cosas como:

• “No puedo usar la variable que declaré antes”
• “Tiene el mismo nombre, pero el valor es diferente”
• “No entiendo por qué no puedo referenciarla aquí”

En esta sección, organizaremos
tipos de variables y ámbito para principiantes.

4.1 ¿Qué es el Ámbito? (Dónde se Puede Usar una Variable)

Ámbito significa
el rango donde se puede usar una variable.

En Java, el ámbito se determina estrictamente por:

• dónde se declara la variable
• el rango de llaves { }

La regla básica es muy simple:

Una variable solo se puede usar dentro del bloque donde se declara

4.2 Variables Locales (Variables Dentro de Métodos)

Las variables locales son variables declaradas dentro de métodos o bloques (como if y for).

public void sample() {
    int x = 10;  // local variable
    System.out.println(x);
}

Esta x tiene estas características:

• Válida solo dentro del método sample
• Desaparece cuando el método termina

Ejemplo de Ámbito con Bloques

if (true) {
    int y = 5;
    System.out.println(y);
}

System.out.println(y); // Error

Porque y se declara dentro del bloque if, no se puede usar fuera de él.

Reglas Importantes para Variables Locales

Las variables locales tienen reglas estrictas:

• No se pueden usar a menos que se inicialicen
• No se asignan valores predeterminados automáticamente

  int value;
  System.out.println(value); // compile-time error
  

Esto es parte del diseño de seguridad de Java para prevenir el uso de “valores indefinidos”.

4.3 Campos (Variables de Instancia)

Los campos son variables declaradas dentro de una clase pero fuera de los métodos.

public class Sample {
    int count;  // field (instance variable)

    public void printCount() {
        System.out.println(count);
    }
}

Los campos tienen características diferentes a las variables locales:

• Cada instancia de la clase tiene su propia copia
• Se inicializan automáticamente con valores predeterminados
• Se pueden usar desde cualquier método en la clase

Valores Predeterminados para Campos

Dependiendo del tipo, se establecen automáticamente los siguientes valores predeterminados:

• int → 0
• double → 0.0
• boolean → false
• Tipos de referencia → null

Por lo tanto, el siguiente código no produce un error:

public class Sample {
    int count;

    public void print() {
        System.out.println(count); // 0
    }
}

Sin embargo, no se recomienda depender demasiado de los valores predeterminados.
La inicialización explícita hace que la intención del código sea más clara.

4.4 Variables static (Variables de Clase)

Una variable con static se convierte en
una variable compartida en toda la clase.

public class Counter {
    static int total = 0;
}

Esta total tiene estas características:

• Solo existe una por clase
• Compartida por todas las instancias

Modelo Mental para Variables static

• Variables de instancia → la billetera de cada persona
• Variables static → una caja fuerte compartida de la empresa

Ese modelo facilita la comprensión.

Precauciones para Variables static

Las variables static son útiles, pero almacenar demasiado estado puede causar errores.

• Es difícil rastrear dónde ocurrieron los cambios
• Las pruebas se vuelven más difíciles
• Los problemas son más probables en el procesamiento concurrente

Como principiante, se recomienda limitar su uso a cosas como:

• Constantes
• Valores de configuración compartidos

y propósitos similares.

4.5 Cuidado con Variables con el Mismo Nombre (Sombreo)

Mira el siguiente código:

public class Sample {
    int value = 10;

    public void test() {
        int value = 5;
        System.out.println(value);
    }
}

En este caso, la salida es 5.

Esto se debe a que
la variable local está ocultando el campo (sombreo).

Dado que esto es una fuente común de confusión para principiantes:

• Evita nombres de variables duplicados
• No reutilices el mismo nombre a menos que sea intencional

Esa disciplina importa.

4.6 Resumen de la Sección

• Alcance significa “el rango donde una variable puede ser usada”
• Las variables locales son válidas solo dentro de bloques y deben ser inicializadas
• Los campos reciben automáticamente valores por defecto
• Las variables estáticas se comparten en toda la clase
• Ten cuidado con el sombreado causado por variables con el mismo nombre

5. Uso correcto de var (Inferencia de tipos) en Java 10+

Introducido en Java 10, var es una forma de permitir que el compilador infiera el tipo de una variable.

Puede parecer conveniente, pero si se usa incorrectamente, puede conducir fácilmente a “código difícil de leer”. Por eso es importante entender las reglas y cuándo usarlo.

5.1 ¿Qué es var? (Cómo funciona sin escribir el tipo)

En Java normal, declaras una variable así:

String message = "Hello";

Con var, puedes escribir:

var message = "Hello";

En este punto, Java observa el lado derecho "Hello" y decide:

• Esta variable es de tipo String

El punto importante es que var no es tipado dinámico.

• El tipo se determina en tiempo de compilación
• El tipo no cambia en tiempo de ejecución

Así que piensa en var como “una abreviatura que te permite omitir el tipo”.

5.2 Dónde puedes y no puedes usar var

var solo puede usarse en lugares estrictamente definidos.

Dónde puedes usarlo

• Solo variables locales

  public void sample() {
      var count = 10;
  }
  

Dónde no puedes usarlo

Todas las siguientes utilizaciones generan errores:

var x;                 // No initialization → error
var y = null;          // Cannot infer the type → error

class Sample {
    var value = 10;    // Cannot be used for fields → error
}

La razón de estas restricciones es clara: evitar reducir la legibilidad y la seguridad.

5.3 Beneficios de usar var

var brilla cuando el tipo tiende a ser largo.

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

Con var:

var list = new ArrayList<String>();

Se vuelve mucho más limpio.

En otras palabras, var es útil cuando:

• Los genéricos son largos
• El tipo es obvio a partir del lado derecho

Usado de esta manera, puede mejorar la legibilidad.

5.4 Trampas de var (Errores comunes de principiantes)

var es conveniente, pero si los principiantes lo usan en exceso, pueden ocurrir los siguientes problemas.

El tipo se vuelve difícil de ver

var data = getData();

Solo con esta línea, no puedes saber:

• Qué tipo de datos es
• Qué contiene

En casos como este, es más seguro escribir el tipo explícitamente.

Data data = getData();

Puede convertirse en un tipo no deseado

var number = 10;   // int

Los principiantes a menudo se encuentran con casos como, “Pensé que sería largo”.

Cuando no escribes el tipo explícitamente, tu intención y el tipo inferido real pueden divergir, así que ten cuidado.

5.5 Cómo decidir si usar var

Si no estás seguro, usa estos criterios:

• Si el tipo es obvio a partir del lado derecho → var está bien
• Si el tipo tiene un significado importante → escribe el tipo explícitamente
• Código amigable para principiantes / de aprendizaje → escribe el tipo tanto como sea posible
• Desarrollo en equipo → sigue los estándares de codificación

Especialmente durante el aprendizaje, escribir el tipo ayuda a profundizar la comprensión, así que no necesitas obligarte a usar var.

5.6 Resumen de la sección

• var es una abreviatura para la inferencia de tipos
• No es tipado dinámico; el tipo es fijo en tiempo de compilación
• Solo sirve para variables locales y requiere inicialización
• Es importante distinguir cuándo mejora y cuándo reduce la legibilidad

6. “No quiero cambiar este valor”—final y la idea de constantes

En Java, la idea de diseño de “una vez que se decide un valor, no permitir que se cambie después” es muy importante.

La herramienta para eso es final.

Los principiantes a menudo piensan que “final es algo que se pone a las constantes”, pero en realidad tiene un significado más amplio.

6.1 ¿Qué es final? (Impedir la reasignación)

Una variable con final no puede ser reasignada después de que la asignas una vez.

final int maxCount = 10;
maxCount = 20; // compile-time error

La regla es muy simple:

• Puedes inicializarla
• No puedes reasignarla

Eso es todo lo que necesitas recordar.

6.2 ¿Por qué usar final en variables locales?

Agregar final a una variable local deja claro que:

• Esta variable no cambia a mitad de camino
• El valor está fijado

Ayuda a expresar tu intención claramente en el código.

final int basePrice = 100;
int total = basePrice + 20;

Escribiéndolo de esta manera:

• Ayuda a prevenir cambios accidentales
• Hace que el lector se sienta más seguro

Estos son los beneficios.

6.3 Uso de final en campos

Agregar final a un campo lo convierte en
un valor inmutable para esa instancia.

public class User {
    final String name;

    public User(String name) {
        this.name = name;
    }
}

En este caso:

• name solo puede establecerse una vez en el constructor
• No puede cambiarse después

Este es un enfoque de diseño importante para estabilizar el estado del objeto.

6.4 Nota importante para final con tipos de referencia (confusión común de principiantes)

Este es un punto muy importante:

final int[] numbers = {1, 2, 3};
numbers[0] = 100;   // OK
numbers = new int[]{4, 5, 6}; // Error

¿Por qué ocurre esto?

La razón es que final restringe “la reasignación de la referencia”.

• Cambiar el contenido del arreglo → OK
• Cambiar a qué arreglo se refiere la variable → NG

En otras palabras, final no hace que el contenido sea inmutable.

Si no entiendes esto, puedes confundirte y pensar:

• “¿Por qué puede cambiar aunque sea final?”
• “¿Esto es un error?”

Por eso esta distinción es importante.

6.5 ¿Qué es una constante? (static final)

En Java, lo que la gente suele llamar “constante” se define típicamente con static final por convención.

public class Config {
    public static final int MAX_USERS = 100;
}

Este tipo de constante tiene las siguientes características:

• Compartida en toda la clase
• El valor no puede cambiarse
• Puedes darle un nombre significativo

Convención de nombres para constantes

Las constantes generalmente se escriben con el siguiente estilo:

UPPER_SNAKE_CASE

Ejemplo:

static final double TAX_RATE = 0.1;

6.6 Cómo decidir cuándo usar final

Como principiante, los siguientes criterios son fáciles de aplicar:

• Si el valor no necesita cambiar → agrega final
• Valores de configuración / valores base → usa static final
• Si los cambios accidentales serían problemáticos → agrega final

Especialmente en la práctica, una mentalidad común es:

“Si no estás seguro, agrega final.”

En muchos casos, eso brinda un buen equilibrio.

6.7 Resumen de la sección

• Con final, no puedes reasignar la variable
• Puedes usarlo tanto en variables locales como en campos
• final en tipos de referencia no significa “contenidos inmutables”
• Las constantes se definen con static final
• final es una herramienta para escribir código más seguro y claro

7. Valores iniciales, valores por defecto y errores comunes (recuperación de trampas para principiantes)

Hasta ahora, has aprendido sobre declaraciones, tipos, alcance, var y final.
En la práctica, sin embargo, hay muchas situaciones en las que “lo entiendo conceptualmente, pero sigo obteniendo errores.”

En esta sección, organizaremos puntos de tropiezo comunes para principiantes junto con sus causas.

7.1 Las variables locales no reciben valores por defecto

Primero, una regla muy importante:

Las variables locales no reciben valores por defecto automáticos

El siguiente código produce un error en tiempo de compilación:

public void sample() {
    int x;
    System.out.println(x); // Error
}

La razón es simple: Java no permite el estado donde “no sabemos qué hay dentro de x”.

Enfoque correcto

public void sample() {
    int x = 0;
    System.out.println(x);
}

Para las variables locales, sigue estrictamente la regla: siempre inicialízalas tú mismo.

7.2 Los campos obtienen valores predeterminados automáticamente

Por otro lado, los campos (variables de instancia y variables estáticas)
se asignan valores iniciales automáticamente.

public class Sample {
    int count;
    boolean active;
    String name;
}

Los valores predeterminados son los siguientes:

• int → 0
• double → 0.0
• boolean → false
• Tipos de referencia → null

Por lo tanto, el siguiente código no produce un error:

public class Sample {
    int count;

    public void print() {
        System.out.println(count); // 0
    }
}

Sin embargo, no se recomiendan diseños que dependan de valores predeterminados.
Hacen más difícil ver la intención y pueden convertirse fácilmente en un caldo de cultivo para errores.

7.3 Errores causados por null (NullPointerException)

El valor predeterminado para los tipos de referencia es null.

String text;

Si llamas a un método en este estado, obtendrás un error en tiempo de ejecución:

System.out.println(text.length()); // NullPointerException

Esta es una de las excepciones más comunes con las que se encuentran los principiantes.

Contramedidas básicas

• Inicializa siempre que sea posible
• Considera la posibilidad de null
• Diseña para evitar usar null de manera no intencional

  String text = "";
  

Incluso inicializar con una cadena vacía puede prevenir muchos accidentes.

7.4 Usar una variable fuera de su ámbito

Lo siguiente es otro error común:

if (true) {
    int value = 10;
}

System.out.println(value); // Error

Este es un problema de referencia fuera del ámbito.

• value es válido solo dentro del bloque if
• Fuera del bloque, no existe

Reconfirma esa regla.

7.5 Confusión por variables con el mismo nombre (Sombreado revisitado)

public class Sample {
    int value = 10;

    public void test() {
        int value = 5;
        System.out.println(value);
    }
}

Este código imprime 5.

Los principiantes a menudo piensan erróneamente:

• Se usará el valor del campo

Pero en realidad,
el ámbito interno tiene prioridad.

Dado que el sombreado causa confusión:

• Usa nombres de variables distintos basados en roles

Tenlo en cuenta.

7.6 Errores de compilación por incompatibilidades de tipos

La siguiente asignación no está permitida:

int number = 3.14; // Error

Esto se debe a:

• double → int no se convierte automáticamente

Esa es la regla.

Enfoque correcto (cuando lo intentas)

int number = (int) 3.14; // 3

Sin embargo, ten cuidado de que la parte decimal se trunca.

7.7 Resumen de la sección

• Las variables locales deben inicializarse
• Los campos obtienen valores predeterminados, pero no dependas demasiado de ellos
• null a menudo causa errores en tiempo de ejecución
• No puedes usar variables fuera de su ámbito
• Las incompatibilidades de tipos se previenen con errores de compilación

8. Resumen: Puntos clave para dominar primero en las variables de Java

En este artículo, organizamos el tema de “las variables de Java” paso a paso,
centrándonos en puntos que los principiantes comúnmente encuentran confusos.

Finalmente, resumamos los puntos clave
en una forma útil tanto para el aprendizaje como para la codificación en el mundo real.

8.1 Piensa en las variables de Java como un conjunto de “Tipo, Nombre y Valor”

Las variables de Java siempre vienen con estos tres elementos:

• Tipo : qué tipo de valor contiene
• Nombre : qué representa el valor
• Valor : los datos reales almacenados

  int count = 10;
  

Esta sola línea contiene la esencia completa de las variables de Java.

8.2 Distingue claramente la declaración, la asignación y la inicialización

Una trampa común para principiantes es difuminar las diferencias entre estos tres términos:

• Declaración: preparar el uso de una variable
• Asignación: poner un valor en ella
• Inicialización: declarar y asignar al mismo tiempo

Especialmente para las variables locales,
recuerda la regla: no puedes usarlas a menos que se inicialicen.

8.3 Sé consciente de la diferencia entre tipos primitivos y tipos de referencia

Los tipos de Java se dividen ampliamente en dos categorías:

. Tipos primitivos: manejan el valor en sí
Tipos de referencia: manejan la ubicación (referencia) del valor

Tener presente esta diferencia te ayuda a comprender de forma natural:

• Copia de valores
• Cómo se comportan los arreglos y los objetos
• Qué significa realmente final

8.4 Entender el alcance reduce drásticamente los errores

Las variables solo pueden usarse dentro del lugar donde se declaran.

• Variables locales → válidas solo dentro de bloques
• Campos → disponibles en toda la clase
• Variables estáticas → compartidas en toda la clase

Si alguna vez piensas “no sé por qué no puedo usarla”,
primero sospecha del alcance.

8.5 Usa var y final según el propósito

• var → Úsalo solo cuando el tipo sea evidente y mejore la legibilidad
• final → Úsalo para expresar claramente la intención “este valor no debe cambiar”

Ambos son convenientes, pero ten cuidado de no convertir “usarlos” en el objetivo mismo.

8.6 Directrices para principiantes que desean programar con seguridad

Durante la fase de aprendizaje, las siguientes políticas reducen los errores:

• Inicializa las variables al declararlas
• Escribe los tipos explícitamente siempre que sea posible
• Usa nombres significativos
• Si tienes dudas, prueba añadiendo final

Incluso esto solo te acerca a código Java legible y seguro.

8.7 Próximos temas para profundizar la comprensión

Una vez que comprendas las variables, se recomienda pasar a:

• Condicionales (if / switch)
• Bucles (for / while)
• Arreglos y colecciones (List / Map)
• Métodos y parámetros
• Conceptos básicos de programación orientada a objetos

Las variables son la base de todo el código Java.

Al entenderlas a fondo, tu aprendizaje posterior será mucho más fluido.