En nuestro primer ejemplo escribíamos un texto en pantalla, pero este texto
estaba prefijado dentro de nuestro programa.
Esto no es lo habitual: normalmente los datos que maneje nuestro programa serán el resultado de alguna operación matemática o de cualquier otro tipo. Por eso, necesitaremos un espacio en el que ir almacenando valores temporales y resultados.
En casi cualquier lenguaje de programación podremos reservar esos "espacios", y asignarles un nombre con el que acceder a ellos. Esto es lo que se conoce como "variables".
Por ejemplo, si queremos que el usuario introduzca dos números y el ordenador calcule la suma de ambos números y la muestre en pantalla, necesitaríamos el espacio para almacenar al menos esos dos números iniciales (en principio, para la suma no sería imprescindible, porque podemos mostrarla en pantalla nada más calcularla, sin almacenarla previamente en ningún sitio). Los pasos a dar serían los siguientes:
Pues bien, en este programa estaríamos empleando dos variables llamadas
"primerNumero" y "segundoNumero". Cada una de ellas sería
un espacio de memoria capaz de almacenar un número.
El espacio de memoria que hace falta "reservar" será distinto según la precisión que necesitemos para ese número, o según lo grande que pueda llegar a ser dicho número. Por eso, tenemos disponibles diferentes "tipos de variables".
Por ejemplo, si vamos a manejar números sin decimales ("números enteros") de como máximo 9 cifras, nos interesaría el tipo llamado "int" (abreviatura de "integer", que es "entero" en inglés). Este tipo de datos consume un espacio de memoria de 4 bytes (1 Mb es cerca de 1 millón de bytes). Si no necesitamos guardar datos tan grandes (por ejemplo, si nuestros datos va a ser números inferiores a 1.000), podemos emplear el tipo de datos llamado "short" (entero "corto").
Los tipos de datos númericos disponibles en Java son los siguientes:
|
Nombre |
¿Admite decimales? |
Valor mín. |
Valor máx. |
Precisión |
Ocupa |
|
byte |
no |
-128 |
127 |
- |
1 byte |
|
short |
no |
-32.768 |
32.767 |
- |
2 bytes |
|
int |
no |
-2.147.483.648 |
2.147.483.647 |
- |
4 bytes |
|
long |
no |
-9.223.372.036.854.775.808 |
9..223.372.036.854.775.807 |
- |
8 bytes |
|
float |
sí |
1.401298E-45 |
3.402823E38 |
6-7 cifras |
4 bytes |
|
double |
sí |
4.94065645841247E-324 |
1.79769313486232E308 |
14-15 cifras |
8 bytes |
La forma de "declarar" variables de estos tipos es la siguiente:
int
numeroEntero; // La variable numeroEntero será un número de
tipo "int"
short
distancia; // La variable distancia guardará números
"short"
long
gastos; // La variable gastos
es de tipo "long"
byte
edad; // Un entero
de valores "pequeños"
float
porcentaje; // Con decimales, unas 6 cifras de precisión
double numPrecision;
// Con decimales y precisión de unas 14 cifras
(es decir, primero se indica el tipo de datos que guardará la variable y después el nombre que queremos dar a la variable).
Se pueden declarar varias variables del mismo tipo "a la vez":
int primerNumero, segundoNumero; // Dos enteros
Y también se puede dar un valor a las variables a la vez que se declaran:
int a =
5; //
"a" es un entero, e inicialmente vale 5
short b=-1, c,
d=4; // "b" vale -1, "c" vale 0, "d"
vale 4
Los nombres de variables pueden contener letras y números (y algún otro símbolo, como el de subrayado, pero no podrán contener otros muchos símbolos, como los de las distintas operaciones matemáticas posibles, ni podrán tener vocales acentuadas o eñes).
Vamos a aplicarlo con un ejemplo sencillo en Java que sume dos números:
/* -------------------------------*
* Introducción a Java - Ejemplo *
* -------------------------------*
* Fichero:
suma.java *
* (Suma dos números enteros) *
* -------------------------------*/
class Suma2 {
public static void main( String args[] ) {
int
primerNumero = 56; // Dos enteros con valores prefijados
int segundoNumero = 23;
System.out.println( "La suma es:" ); // Muestro un mensaje de
aviso
System.out.println(
primerNumero+segundoNumero
);
// y el resultado de la operación
}
}
Hay una importante diferencia entre las dos órdenes "println": la primera contiene comillas, para indicar que ese texto debe aparecer "tal cual", mientras que la segunda no contiene comillas, por lo que no se escribe el texto "primerNumero+segundoNumero", sino que se intenta calcular el valor de esa expresión (en este caso, la suma de los valores que en ese momento almacenan las variables primerNumero y segundoNumero, 56+23 = 89).
Lo correcto habría sido que los datos no los
hubiéramos escrito nosotros en el programa, sino que fuera el usuario quien los
hubiera introducido, pero esto es algo relativamente complejo cuando creamos
programas "en modo texto" en Java (al menos, comparado con otros
lenguajes anteriores), y todavía no tenemos los conocimientos suficientes para
crear programas en "modo gráfico", así que más adelante veremos cómo
podría ser el usuario de nuestro programa el que introdujese los valores que
desea sumar.
Tenemos otros dos tipos básicos de variables, que no son para datos numéricos:
Estos ocho tipos de datos son lo que se conoce como "tipos de datos primitivos"
(porque forman parte del lenguaje estándar, y a partir de ellos podremos crear
otros más complejos).
Nota para C y C++: estos tipos de datos son muy similares a los que
se emplean en C y en C++, apenas con alguna "pequeña" diferencia,
como es el hecho de que el tamaño de cada tipo de datos (y los valores que
puede almacenar) son independientes en Java del sistema que empleemos, cosa que
no ocurre en C y C++, lenguajes en los que un valor de 40.000 puede ser válido
para un "int" en unos sistemas, pero "desbordar" el máximo
valor permitido en otros. Otra diferencia es que en Java no existen enteros sin
signo ("unsigned"). Y otra más es que el tipo "boolean" ya
está incorporado al lenguaje, en vez de corresponder a un entero disinto de
cero