Las variables son una de las características fundamentales de los lenguajes de programación, permiten acceder a la

memoria para almacenar y recuperar los datos con los que nuestros programas van a trabajar. Son por tanto el
mecanismo que los lenguajes de programación ponen a nuestra disposición para acceder a la memoria.
Se trata de un mecanismo de lo más sencillo, sólo tenemos que dar un nombre a nuestras variables, a partir de ese
momento el compilador traducirá de forma automática ese nombre en un acceso a memoria. Por ejemplo:

//Almacenamos un dato en memoria referenciado por el nombre edad

edad = 5;
//Recuperamos el dato almacenado y lo modificamos
edad = edad + 1;

Java es un lenguaje tipado y nos obliga a declarar nuestras variables antes de poder hacer uso de ellas, con esta
declaración le indicamos al compilador el espacio en memoria que debe de reservar para almacenar la información. Por
ejemplo:

String cliente;

Aquí estamos reservando memoria para una variable de tipo String y la identificamos con el nombre “cliente”. De ahora
en adelante si en el programa hablamos de cliente, estamos haciendo referencia a esa porción de memoria y al valor que
contiene.
Podemos asignarle algún valor en el momento de declarar una variable. Por ejemplo:

String cliente = "Isaac Newton";

Aquí reservamos memoria para una cadena de caracteres y le asignamos el valor "Isaac Newton". También podemos
declararla y en otro lugar del programa fijarle un valor :

String cliente; // declaración

... // El programa sigue
cliente = "Isaac Newton"; // le damos un valor

La sentencia para declarar una variable se resume como:

Tipo_de_Dato Nombre_de_Variable [= Valor_inicial];

Definimos el tipo de dato, el nombre y opcionalmente su valor inicial.

Para ver como se utilizan las variables, podemos modificar el primer programa. Agregaremos una variable que contenga
el texto que se mostrará en pantalla:

public class HolaMundo {

public static void main(String[] args){
String saludo = "¡Hola Mundo!";
System.out.println( saludo );
}
}

Definimos una variable de tipo String con el nombre "saludo". En la declaración de la variable también la iniciamos con el
valor "¡Hola mundo!". Luego llamamos al método que imprimirá el texto en la pantalla haciendo referencia a la variable.
En el programa original, explícitamente introducíamos el texto que se mostraría, ahora solo escribimos el nombre de la
variable. Cuando el intérprete se encuentre con el nombre de esta variable, tendrá que buscar el valor que almacene en
la memoria para mostrarlo por pantalla.
Un variable puede cambiar su valor en el transcurso del programa (salvo que se preceda su definición con la palabra:
final)
public class UsoVariables {
public static void main(String args[]){
String saludo;
saludo = "Hola Mundo!";
System.out.println(saludo);
saludo = ("Estoy utilizando variables");
System.out.println( saludo );
}
}

Siempre debemos inicializar una variable. Al compilar el programa, el compilador de Java leerá el contenido de la variable
y siempre verificará que tenga un valor. De lo contrario el programa no compilará y mostrará un error. Un ejemplo de este
caso:

int x;
if (x > 0) {
saludo = "Hola Mundo!!!";
}
System.out.println( saludo );

En este caso el compilador mostrará un mensaje de error indicando que la variable x no se ha iniciado con ningún valor.
Como se puede observar esta variable solo se inicia cuando se cumple una condición, sin embargo se indica que va a
ser utilizada siempre. El compilador detecta este posible error. Un ejemplo de solución posible sería:

int x = 1;

if (x > 0) {
saludo = "Hola Mundo!";
}
System.out.println( saludo );

Agregando estas líneas al final del código de la clase UsoVariables nos mostraría lo siguiente a la salida:

Hola Mundo!
Estoy utilizando variables
Hola Mundo!!!

Nombre de la variable
El nombre debe ser único en el contexto del programa. Además debe seguir las siguientes reglas:

• No puede ser una palabra reservada del lenguaje o un literal booleano (true o false)
• Puede contener cualquier carácter Unicode, pero no puede comenzar con un número
• No debe contener los símbolos que se utilicen como operadores ( + , - , ?, etc )

Por convención, los nombres de variables comienzan con una letra en minúscula. Si un nombre consiste en más
de una palabra, se escribirá sin espacios entre ellas y cada palabra (salvo la primera) comenzará con una letra
mayúscula (por ejemplo : estaBienEsteNombre )

Tipo de variable
Cada variable debe tener un tipo de dato predefinido. Esto determina el rango de valores que puede almacenar y qué
operaciones se pueden realizar así como el resultado que te dará. Por ejemplo, una variable de tipo entero puede
almacenar números sin decimales y puede realizar operaciones aritméticas, pero no puede contener palabras.
Existen dos categorías de variables: las de tipo primitivo y las referenciadas. Una variable de tipo primitivo accede al
valor asignado directamente. Las referenciadas acceden a través de un puntero, es decir, no almacenan un valor
sino una dirección de memoria. Estas últimas son utilizadas por las matrices, las clases y las interfaces.

Tipos de datos primitivos

Tipo Tamaño y formato Rango
enteros

byte 8 bits - complemento a 2

short 16 bits - complemento a 2

int 32 bits - complemento a 2

long 64 bits - complemento a 2

números reales
float 32 bits - IEEE 754
double 64 bits - IEEE 754
otros
char 16 bits - caracteres UNICODE '\u0000' al '\uffff'
boolean 1 bit true o false

En otros lenguajes de programación, el formato o el tamaño de los tipos primitivos dependen del microprocesador o
del sistema operativo en el que se están ejecutando. En cambio, Java pretende ser independiente de la plataforma y
mantiene los formatos sin cambios. Para los caracteres alfanuméricos utiliza la codificación UNICODE de 16 bits,
para permitir la inclusión de varios alfabetos.
Existen 2 tipos de variables en Java:

▪ Primitivas:

Puede ser cualquiera de los 8 tipos: char, boolean, byte, short, int, long, double o float. Una vez que un primitivo ha sido
declarado, el tipo primitivo no puede cambiar nunca, sin embargo su valor sí.

▪ Variables de Referencia:

Una variable de referencia es usada para referenciar (o acceder) a un objeto. Una variable de referencia es declarada para ser
un tipo específico y el tipo no puede ser nunca cambiado. Una variable de referencia puede ser usado para referir a cualquier
objeto del tipo declarado, o a un subtipo del tipo declarado (un tipo compatible).

▪ Declarando Primitivos y Rangos Primitivos

Las variables primitivas pueden ser declaradas como variables de clase (static), variables de instancia, parámetros de métodos,
o variables locales. Vamos a ver un ejemplo de estas declaraciones:

1
byte b;
2
boolean myBooleanPrimitive;
3
int x, y, z; //Declara 3 enteros primitivos
4

Para los tipos enteros la secuencia desde mas pequeños hasta mas grandes es byte, short, inty long, y double es mas grande
que float. Ambos, enteros como tipos de puntos flotantes tienen signo, y esto afecta a sus rangos. Primero vamos a echar un
vistazo a los conceptos.

Cualquier tipo de número en Java están hechos con un número concreto de 8-bit bytes, y tienen signo, lo que quiere decir que
pueden ser negativo o positivos. El bit que está a la izquierda es usado para representar el signo, donde un 0 significa negativo
y un 1 significa positivo. El resto de bits representa el valor, usando 2 notaciones complementarias.

-1

Tipo Bits Bytes Rango Mínimo Rango Máximo

byte 8 1 -27 27

short 16 2 -215 215-1

int 32 4 -231 231-1

long 64 8 -263 263-1

float 32 4 n/a n/a

double 64 8 n/a n/a

Para los tipos boolean no hay rango; un boolean solo puede ser true o false.

El tipo char contiene un caracter singular de 16-bit Unicode.Aunque el ASCII extendido conocido como ISO Latin-1 necesita
solo 8 bits(256 caracteres diferentes), se necesita un rango mayor para representar caracteres que se encuentren en otras
lenguas diferentes al Inglés.

▪ Declarando Variables de Referencia

Las variables de referencia pueden ser declaradas como variables estáticas, variables de instancia, parametros de métodos, o
como variables locales. Podemos declarar una o mas variables de referencia, del mismo tipo, en una misma linea. Ahora vamos
a ver un ejemplo de este tipo de variables:

1 Object o;
2 Dog myNewDogReferenceVariable;

3 String s1, s2, s3; //Declara 3 variables de tipo String

▪ Variables de Instancia

Las variables de instancia son definidas dentro de la clase, pero fuera de cualquier método, y son solo inicializadas cuando la
clase es instanciada. Las variables de instancia son los campos que pertenecen a cada objeto único. Por ejemplo vamos a ver
un objeto Employee:

1
class Employee{
2
//define los campos (variables de instancia) para el Empleado
3
private String name;
4
private String title;
5
private String manager;
6
//Otro código iría aqui
7
}
8

La clase Employee dice que de cada isntancia de Empleado se sabrá su nombre, el titulo, y el manager. Cada instancia puede
tener su propios valores únicos para sus 3 campos. “field”, “variables de instancia”, “propiedades”, “atributos”, todo esto
virtualmente se refiere a lo mismo.

Hay que tener en cuenta varias cosas sobre las variables de isntancia:

▪ Pueden usar cualquiera de los 4 niveles de acceso.

▪ Pueden ser marcados como final.

▪ Pueden ser marcados como transient.

▪ No pueden ser marcados como abstract.

▪ No pueden ser marcados como synchronized.

▪ No pueden ser marcados como strictfp.

▪ No pueden ser marcados como native.

▪ No pueden ser marcados como static, porque entonces se convertirían en variables de la clase.

Esta tabla puede ayudarnos un poco a recordar:

Variables Locales Variables (no locales) Métodos

final final final

public public

protected protected

private private

static static

transient
 volatile

abstract

synchronized

strictfp

native

▪ Variables locales (Automaticas/Stack/Métodos)

Las variables locales son declaradas dentro de un método. Esto significa que la variable no solo se inicializa dentro del método,
sino que tambien se declara dentro del método. Al igual que empieza su vida en el método, tambien se destruye cuando el
método se ha completado. Las variables locales siempre están en el stack, no en el heap. Aunque el valor de la variable pueda
ser pasada dentro, por decirlo así, de otro método que guarde el valor en una variable de instancia, la variable porsí misma
solo vive dentro del ámbito del método.

La declaración de una variable local no puede usar la mayoría de los modificadores que pueden ser aplicados a las variables de
instancia, como public, transient, volatile, abstract o static, pero como ay dijimos con anterioridad, pueden ser marcados
como final. Antes de usar una variable local, esta debe ser inicializada con algún valor. Por ejemplo:

1
class TestServer{
2
public void logIn() {
3
int count = 10;
4
}
5
}
6

Típicamente, inicializaremos la variable local en una misma línea en la cual la declaremos, aunque podemos aun necesitar
reinicializarla mas tarde en el método. La clave de todo esto es recordar que una variable local debe ser inicializada antes de
que se intente usar, ya que las variables locales no tienen valores por defecto, al contrario que las variables de instancia.

No puede ser referenciada en cualquier lugar del código fuera del método en el cual ha sido declarado. En el ejemplo anterior
sería imposible referenciar la variable count en cualquier lugar de la clase excepto dentro del ámbito del método logIn(). A
continuación vemos un ejemlo de código que es ilegal:

{sourcecode language=”java”]
class TestServer{
public void logIn(){
int count = 10;
}
public void doSomething(int i){
count = i; //No compilará!, No se tiene acceso a count fuera del método logIn()
}
}
[/sourcecode]

Es posible declarar una variable local con el mismo nombre que una variable de instancia, a esto se le conoce como shadowing:

1 class TestServer{

2 int count = 9; //Se declara una variable de instancia llamada count

3 public void logIn(){

4 int count = 10; //Declara una variable local llamada count

5 System.out.println("La variable local count es " + count);

6 }

7 public void count(){

8 System.out.println("La variable de instancia es " + count);

9 }

10 public static void main (String[] args){

11 new TestServer().logIn();

12 new TestServer().count();

13 }

14 }

15

El anterior código generará una salida como la siguiente:

1
La variable local count es 10
2
La variable de instancia es 9
3

▪ Declaración de Arrays

En Java, los arrays son objetos que almacenan multiples variables de un mismo tipo, o variables que son subclases del mismo
tipo. Los arrays pueden mantener ya sean variables primitivas o referencias a objetos, pero por sí mismo siempre serán objetos
localizados en el heap, aunque el array sea declarado para mantener elementos primitivos.

Los arrays son declarados poniendo el tipo de dato de los elementos que guardará (Objetos o primitivos), seguido de corchetes
cerrados y seguido por el identificados.

1
int[] key; //Corchetes antes del nombre (recomendado)int key[]; // Corchetes despues del nombre (legal pero menos legib
2

1
Thread[] threads; //Recomendado
2
Thread threads []; //Legal pero menos legible
3

También podemos declarar arrays multidimensionales, los cuales son al fin y al cabo arrays de arrays.

1
String[][][] occupantName;
2
String[] managerName [];
3

El primer ejemplo es un array tridimensional (un array de arrays de arrays) y el segundo es un array de dos dimensiones. En el
segundo ejemplo tenemos unos corchetes antes del nombre de la variable y otro despues del nombre. Esto es legal para el
compilador, pero tenemos que pensar de nuevo en que lo legal no significa que esté bien.

▪ Variables Final

Declarar una variable con la palabra clave final hace que sea imposible reinicializar la variable una vez que ha sido inicializada
con un valor explícito. Para las variables primitivas, esto significa que una vez que se le ha asignado un valor, el valor no puede
ser alterado. Esto es fácil hablando de las variables primitivas, pero ¿Qué pasa si tenemos una referencia a un objeto final?
Una variable de referencia marcada como final no puede ser reasignada para referir a otro objeto diferente. La información
dentro del objeto puede ser modificado, pero la variable de referencia no puede ser cambiara. En otras palabras, una
referencia final aun permitirá modificar el estado del objeto al que refiere, pero no podemos modificar la variable de referencia
para ahcer que se refiera a otro objeto diferente. Por tanto, tenemos que grabar esto en nuestra cabeza: No hay objetos final,
solo referencias final.

▪ Variables Transient

Si marcamos una variable de instancia como transient, le estamos diciento a la JVM que ignore o se salte a esta variable cuando
intentemos serializar el objeto que la contiene. La serialización es una de las características mas importantes de Java, ya que
nos permite guardar/salvar un objeto escribiendo su estado en un tipo especial de I/O stream. Con la serialización podemos
guardar un objeto en un archivo, o o mandarlo a otro lugar donde se deserializa en otro sitio, en otra JVM.

▪ Variables volatile

El modificador volatile le dice a la JVM que un hilo que acceda a la variable debe siempre reconciliar su propia copia privada
de la variable con una copia maestra en memoria. Esto es solo aplicable a variables de instancia.

▪ Métodos y Variables static

El modificador static es usado para crear variables y métodos que existirán independientemente de cualquier instancia creada
de la clase. Todos los miembros staticexisten antes de que se haga una nueva instancia de la clase, y siempre habrá una sola
copia del miembro static sin tener en cuenta el numero de instancias de la clase. En otras palabras, todas las instancias de una
clase dada comparten el mismo valor para una variable static dada.

Cosas que podemos marcar como static:

▪ Métodos.

▪ Variables.

▪ Una clase anidada dentro de otra clase, pero no dentro de un método.

▪ Bloques de Inicialización.

Cosas que no podemos marcar como static:

▪ Constructores.

▪ Clases (A no ser que estén anidadas).

▪ Interfaces.

▪ Métodos locales dentro de las clases.

▪ Métodos internos de la clase y variables de instancia.

▪ Variables locales.