Java Tip 9: Variables

Una variable está formada por un espacio en el sistema de almacenaje (memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una cantidad de información conocida o desconocida, es decir un valor. Su longitud puede ser fija, las que no cambian a lo largo del programa y de longitud variable, las que cambian de tamaño a lo largo del programa.

En cuanto al ámbito o alcance tenemos las globales, las que son accesibles desde cualquier punto del programa y las locales, las que sólo son accesibles desde el punto de declaración.

package pack1;


public class Modelo{
   
   /*Variable de instancia o atributo de clase, se inicializa automáticamente. Con modificador private, sólo accesible desde la propia clase*/
   private String nombre; //null

   /*Constante global, también conocida como variable de clase:  Modelo.MAX */
   public static final int MAX= 100; 

   public void metodo(){
     /*variable local, sólo accesible desde metodo(), es necesaria su inicialización antes de usarse*/
     int variableLocal = 0;
     /*constante local, no puede ser usada en alguna otra parte del programa*/
     final int TAM = 100;
   }


}

En Java existen ocho tipos principales:

Numéricos entero: byte, short, int y long.
Numéricos flotantes o reales: float y double
Booleanos o lógicos: boolean.
Caracter: char.

Además de sus correspondientes clases Wrappers.

Primitive - Wrapper - Constructors
boolean - Boolean - boolean or String
byte - Byte - byte or String
char - Character - char
double - Double - double or String
float - Float - float, double, or String
int - Integer - int or String
long - Long - long or String
short - Short - short or String

Sintaxis:

tipo  nombre = valor; 

Recordemos que toda variable se compone de:

• Un tipo de dato definido.
• Un identificador o nombre.
• Un valor.
• Una dirección en memoria.

Es importante respetar el tamaño de las variables y su tipo. Además de saber qué valor le queremos asignar:

/*Esto no compilará*/
byte Byte = 2000L;
short Short = "120";
int Entero = 1_000_9090L;
long Long = 9090.999;
float flotante = 23.909;
double real = 67.90F;
char car ="A";
boolean verdadero = "true";

Si quieres una variable que solo guarde dos estados deberás usar un boolean y/o Boolean (true/false). Si quieres guardar un valor de tipo carácter, entonces deberás usar un tipo Character y/o char y no un String. Si no necesitas guardar una gran cantidad de valores numéricos o no necesitas que éstos tengan punto flotante o decimales entonces tu opción serían los tipos byte y short en vez de int, long, float y double. Otro caso sería cuando necesitas tener un id o clave que identifique un objeto y el tipo long o Long serían los adecuados.


El odioso Cast.

El objetivo de hacer esto es: convertir un objeto o variable de un tipo definido a otro.

Tipo ref = (Tipo) valor;

Por ejemplo queremos convertir una variable de tipo long (64 bits o 8 bytes) a una de tipo byte (8 bits o 1 byte). La diferencia es mucha y es por eso que necesitamos hacer "Cast". Es obvio que habrá pérdida de bits

byte Byte = (byte)(short)(int)10000L;
System.out.println("Long: "+(10000L));//Long: 10000
System.out.println("Byte: "+Byte);//Byte: 16
 

Si hubiésemos hecho esto:

byte Byte = (byte)10000L;
System.out.println("Long: "+(10000L));//Long: 10000
System.out.println("Byte: "+Byte);//Byte: 16
 

El resultado sería el mismo.  Es importante saber que los tipos no se convierten automáticamente, por ejemplo no podemos pasar de un byte a un long aunque el byte tenga menos bits. Es necesario hacer el "Cast".

Ahora a hacemos esto:

Long longitud = (long)Byte; 
System.out.println("Long: "+longitud);//Long: 16
 

No podemos hacer simplemente esto:

/*Esto no compilará*/
Long longitud = Byte; 
System.out.println("Long: "+longitud);

Recordemos que:

byte tiene 8 bits o 1 byte

short tiene 16 bit o 2 bytes

int tiene 32 o 4 bytes

long tiene 64 bits  u 8 bytes

float 32 bits o 4 bytes

double 64 bits u 8 bytes

boolean 8 bits o 1 byte

char 16 bits o 2 bytes
 

Nota: También es importante tomar en cuenta el rango (ej. un byte tiene -128 a 127).

Cast entre tipos de clase.

Tengamos las siguientes clases:

/*Superclase: padre de Perro y Gato*/
class Animal{}


/*Subclase de Animal*/
class Perro extends Animal{}


/*Subclase de Animal*/
class Gato  extends Animal{}

Realizamos el Cast.

Animal animal = new Perro();

/*Esto es correcto*/
Perro perro = (Perro) animal;


/*Esto es incorrecto*/
Gato gato = (Gato) animal;

La conversión de perro es correcto, pues el tipo de compatible. La conversión de gato no lo es.

Otros ejemplos:

Object obj = new String("Hola");
/*Esto no se puede, compilara pero en ejecución fallara causando un:
  java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.StringBuilder*/
StringBuilder sb = (StringBuilder) obj;

//Esto es correcto
String str = (String) obj;

Nota: algunos aspectos a notar es que las variables locales deben estar inicializadas antes de usarse y las variables miembro o variables de instancia pueden o no estar inicializadas.

Esto no compilaría:

/*En un método*/

//Esto no compilará: nulo no está inicializado
String nulo;
System.out.println(nulo);

En cambio esto está bien:

package pack1;

public class Modelo{
   //Se inicializa con el valor 0
   private int numero;
}

Por el momento es todo. En posteriores post hablaremos de conceptos importantes en el lenguaje Java como el paso de variables por valor y referencia.

Links:
https://es.wikipedia.org/wiki/Variable_(programaci%C3%B3n)
https://syntaxdb.com/ref/java/type-cast