En este articulo, nos vamos a centrar en entender mejor qué son, cómo funcionan y para qué sirven las variables en Java, además de explicar qué tipos de datos tenemos en este lenguaje de programación (primitivos y no primitivos) y muchas más cosas.
Qué vas as ver en esta entrada
¿Qué es una variable en Java y para qué sirve?
En todo lenguaje de programación las variables son un elemento imprescindible que utilizaremos con el fin de almacenar datos.
Cualquier programa, desde los más simples, necesita almacenar y manipular datos. Para ello, usualmente se utilizan las variables, las cuales “escriben” sobre un espacio de memoria RAM que reservamos para dicha función.
Un ejemplo real podría ser introducir una moneda en una máquina recreativa y que nos indicase cuál queremos que sea nuestro nombre de jugador.
Para ello, usualmente usaremos un tipo de dato. En este caso en concreto, el tipo de dato será String (cadena de texto), ya que el dato que vamos a guardar así lo requiere. Junto al nombre que utilizaremos, almacenaremos y accederemos a la posición que almacena dicho dato en la memoria RAM.
Podemos ver las variables por tanto, como una especie de “cajas o contenedores”, cuyo tamaño dependerá del tipo de dato que definamos en función y que, en caso de los lenguajes de programación alta, lo que queramos almacenar.
Tipos de memorias
Es muy importante el entender que las variables se almacenan en memorias volátiles como son la memoria RAM o la ROM. En el caso del los programas que ejecutamos dentro del sistema operativo, las variable suelen almacenarse la gran mayoría de veces dentro de la memoria RAM.
Diferencias entre memorias volátiles y no volátiles
La principal diferencia entre una memoria volátil y no volátil es que en las volátiles cuando finalicemos la ejecución del programa, sistema operativo, etc., ya sea porque ha finalizado la ejecución o porque se ha interrumpido el suministro eléctrico, etc., perderemos el contenido de dichas variables.
Esto es así, ya que al almacenarse en memoria RAM, cuando el programa finaliza se deja de reservar dicho espacio de memoria para así poder ser utilizado por otro programa. Por tanto, cuando se apaga el equipo, se pierde toda la información que contiene la memoria RAM. Un ejemplo podría ser cuando copiamos un texto. Si reiniciamos ya no lo podemos pegar, ya que se había guardado en la RAM.
En cambio, en las memorias no volátiles, como son los discos duros, por ejemplo, si hemos guardado una imagen y apagamos el sistema, se corta el suministro eléctrico, etc., no perdemos el acceso a dicha información. Otro ejemplo podría ser un documento de Word siempre que se haya guardado.
Muestra de ello es que, si vamos al Administrador de tareas, en rendimiento podemos visualizar el uso de la memoria volátil del ordenador, es decir, de la memoria RAM. Y cómo esta aumenta y disminuye en función de varios factores, entre los que se encuentra, por ejemplo, la cantidad de programas que tengamos abiertos.
Cuanto más uso de memoria tengamos en uso, menos memoria tendremos disponible. Lo que afectará en parte al rendimiento de los programas que estemos ejecutando y del propio sistema operativo.
Declaración de una variable en Java
La declaración de la variable es el proceso en el que definimos qué le indicamos a Java que nos reserve/asigne un espacio de memoria RAM para poder guardar un dato posteriormente en él. Se hace del siguiente modo:
Asignación de un valor a una variable
Una vez hemos definido una variable, ahora solamente nos falta asignarle un valor. Lo haremos de la siguiente manera:
Declaración y asignación en una sola línea
La declaración de una variable y la asignación de un valor en una sola variable sería así:
Y de varias variables a la vez, del siguiente modo:
Ejemplo de variable en Java
Un ejemplo de uso de la variable que hemos definido y a la que hemos asignado un valor sería:
¿Por qué se denominan variables?
El motivo por el que se bautizó como variable a dicho concepto de programación es porque el valor de dicha variable puede cambiar. Vamos a verlo:
El resultado será:
Si nos fijamos, el tipo de dato que almacenamos en la variable lo definimos una sola vez. Pero, en cambio, la asignación de un valor a la variable puede ser utilizada varias veces.
Características de los lenguajes de programación compilados
Unas de las características que posee el lenguaje de programación Java, al ser un lenguaje compilado, es que posee un tipado fuerte y estático. ¿Qué significa esto?
Tipado fuerte
El lenguaje nos obliga a definir el tipo de dato que queremos guardar en una variable. Si creamos una variable de tipo cadena de texto sin especificarle el tipo y vamos a la bombillita, podemos ver que el propio IDE (en este caso Eclipse), nos sugiere que el tipo de dato será String.
Tipado estático
Java nos impide cambiar el tipo de dato que va a contener una variable. Si hemos definido que es una cadena de texto y ponemos un valor numérico (sin comillas), el tipo de dato que estamos asignado no será una cadena de texto y por tanto dará error.
Tipos de datos en Java
Las variables se subdividen en dos grandes grupos:
Tipos de datos primitivos
Los tipos de datos primitivos con los que podemos definir una variable se pueden categorizar bajo las siguientes categorías y subcategorías:
Ejemplos de uso de variables primitivas
Vamos a ver un ejemplo de uso de cada una de las variables:
public class Main {
public static void main(String[] args) {
boolean interruptor = true; // Permite almacenar valores true or false
System.out.println("Ejemplo valor boolean " + interruptor);
System.out.println();
char caracter = '\u0061'; // Permite almacenar un caracter Unicode
System.out.println("Ejemplo de caracter en formato unicode: " + caracter);
caracter = 'a';
System.out.println("Ejemplo de caracter: " + caracter);
System.out.println();
byte byteNumber = 15; //
System.out.println("Ejemplo de un dato de dato tipo byte: " + byteNumber);
System.out.println();
short shortNumber = 66;
System.out.println("Ejemplo de un dato tipo short: " + shortNumber);
System.out.println();
int intNumber = 1234;
System.out.println("Ejemplo de un dato tipo integer: " + intNumber);
System.out.println();
long longNumber = 2365;
System.out.println("Ejemplo de un dato tipo long: " + longNumber);
System.out.println();
float floatNumber = 12345f;
System.out.println("Ejemplo de un dato tipo float: " + floatNumber);
double doubleNumber = 1234.25;
System.out.println();
System.out.println("Ejemplo de un dato tipo double: " + doubleNumber);
}
}El resultado será:
Tipos de datos no primitivos
Dentro de las variables de Java no primitivas, una de las más populares es la clase String, sobre la que ya hemos trabajado en el inicio del artículo.
Para hacer un poco de memoria, vamos a ver el ejemplo que habíamos visto anteriormente:
¿Cómo saber si un objeto es primitivo o no primitivo en Java?
Todo en Java es un objeto, inclusive lo son las variables que definimos, tanto las primitivas como las no primitivas. Aunque en Java todo es considerado un objeto, vamos a realizar un programa que nos permitirá confirmar si estamos trabajando sobre un objeto primitivo o no primitivo:
public class Main {
public static void main(String[] args) {
String saludo = "Hola";
isWiderPrimitive(saludo);
}
public static void isWiderPrimitive(Object object) {
if (object == null) {
System.out.println("La variable es null, al no tener un valor asignado, no se puede analizar el tipo");
}
Class<? extends Object> clazz = object.getClass();
if (clazz == Boolean.class || clazz == Character.class ||
clazz == Byte.class || clazz == Short.class ||
clazz == Integer.class || clazz == Long.class ||
clazz == Float.class || clazz == Double.class) {
printType(object, true);
}else {
printType(object, false);
}
}
public static void printType(Object object, boolean result) {
if(result) {
System.out.println("Es un tipo primitivo " + object.getClass());
} else {
System.out.println("Es un tipo no primitivo " + object.getClass());
}
}
}El resultado será:
En cambio, si realizamos lo mismo con un tipo de dato int, podemos ver que:
public class Main {
public static void main(String[] args) {
int dni = 12345678;
isWiderPrimitive(dni);
}
public static void isWiderPrimitive(Object object) {
if (object == null) {
System.out.println("La variable es null, al no tener un valor asignado, no se puede analizar el tipo");
}
Class<? extends Object> clazz = object.getClass();
if (clazz == Boolean.class || clazz == Character.class ||
clazz == Byte.class || clazz == Short.class ||
clazz == Integer.class || clazz == Long.class ||
clazz == Float.class || clazz == Double.class) {
printType(object, true);
}else {
printType(object, false);
}
}
public static void printType(Object object, boolean result) {
if(result) {
System.out.println("Es un tipo primitivo " + object.getClass());
} else {
System.out.println("Es un tipo no primitivo " + object.getClass());
}
}
}En este caso el resultado será:
Conclusión
En este artículo hemos visto qué son las variables en Java, para qué sirven, cómo definirlas y cómo asignarles un valor. También hemos diseccionado los tipos de datos en Java, primitivos y no primitivos. El mundo de las variables es extremadamente extenso y, como ya habéis comprobado, si rizamos el rizo, puede llegar a ser mucho más complejo y profundo de lo que parece. ¡Espero que os sea de utilidad el post!
¡Aprende más sobre Java en nuestro canal de YouTube! ¡Suscríbete! ¿Te gustaría impulsar tu negocio con un proyecto de desarrollo en Java? Contacta con nosotros. ¡Te ayudamos a hacer posible grandes ideas!
