Variables y Tipos de Datos

Primeros pasos en Java

Anteriormente, vimos cómo instalar Java en nuestra computadora y realizamos un ejemplo. En este tema, explicaremos en detalle el código que utilizamos.

Estructura de un programa en Java

Un programa en Java requiere de una estructura específica para poder ser ejecutado.

Debemos definir una clase pública, la cual se establece por convención con el mismo nombre del archivo que la contiene. En nuestro caso, la clase se llama HolaMundo, y el archivo también se llama HolaMundo.java.
```
1
public class HolaMundo {
2
    // ...
3
}
```
Dentro de la clase, debemos definir un método público y estático llamado main. Este método es el punto de entrada del programa, es decir, es el método que se ejecutará primero. Este método recibe como parámetro un arreglo de cadenas de texto, el cual contiene los argumentos que se le pasan al programa al momento de ejecutarlo (más adelante veremos cómo pasar argumentos a un programa).
```
1
public class HolaMundo {
2
    public static void main(String[] args) {
3
        // ...
4
    }
5
}
```
Dentro del método main, podemos escribir el código que queremos que se ejecute. Una vez más, en el ejemplo anterior, solo mostramos un mensaje en la consola.
```
1
public class HolaMundo {
2
    public static void main(String[] args) {
3
        System.out.println("Hola Mundo!");
4
    }
5
}
```

Expresiones y sentencias

Ahora que conocemos la estructura básica de un programa en Java, podemos comenzar a programar.

Una sentencia es una instrucción que le indica a la computadora que realice una acción. Por ejemplo, la siguiente sentencia indica a la computadora que muestre el mensaje Hola Mundo! en la consola.

1
System.out.println("Hola Mundo!");

Las sentencias pueden ser simples o compuestas.

Una sentencia simple es aquella que se ejecuta en una sola línea, como la sentencia anterior.

Por otro lado, una sentencia compuesta es aquella que se ejecuta en varias líneas, como la sentencia:

1
public static void main(String[] args) {
2
    // ...
3
}

Más adelante veremos otros ejemplos de sentencias compuestas.

Comentarios

Los comentarios son porciones de código que no se ejecutan, y que sirven para documentar el código. En Java, existen dos tipos de comentarios: los comentarios de una línea y los comentarios multilínea.

Los comentarios de una línea comienzan con // y finalizan con el final de la línea.

1
// Este es un comentario de una línea

Los comentarios multilínea comienzan con /* y finalizan con */.

1
/*
2
Este es un comentario
3
de varias líneas
4
*/

Variables y tipos de datos

En primer lugar, debemos recordar siempre que Java es un lenguaje de tipado estático, es decir, debemos declarar el tipo de cada variable que utilicemos. Pero, ¿qué es una variable?

En otras palabras, una variable es la unidad básica de almacenamiento de datos de un programa.

Declaración de variables

Para declarar una variable, debemos indicar el tipo de dato que almacenará, seguido del identificador o nombre de la variable. Además, debemos terminar la declaración con un punto y coma (;).

<tipo_de_dato> <nombre_de_variable>;

Por ejemplo, si quisiéramos declarar una variable que almacene un número entero, deberíamos escribir el tipo de dato int y asignarle un identificador, como numero.

1
int numero;

Sin embargo, no podemos emplear cualquier identificador para declarar una variable. Existen ciertas reglas que debemos seguir al momento de asignar un nombre a una variable.

El identificador debe comenzar con una letra o un guión bajo (_). También es válido comenzar con el símbolo de dólar ($), aunque no es recomendable.
El identificador puede contener letras, números, guiones bajos (_) o el símbolo de dólar ($).
El identificador no puede contener espacios. Por ejemplo, numero 1 no es un identificador válido, pero numero_1 o numero1 sí lo son.
El identificador no puede ser una palabra reservada (keyword). Por ejemplo, int es una palabra reservada, por lo que no podemos utilizarla como identificador.

Por convención, las variables en Java se escriben en minúsculas. Además, si el identificador está compuesto por varias palabras, cada palabra debe comenzar con mayúscula, excepto la primera. Por ejemplo, numeroDeIntentos es un identificador válido que sigue esta convención. No se recomienda utilizar guiones bajos (_) para separar palabras en un identificador ni el caracter $.

Por otro lado, es recomendable utilizar nombres que sean descriptivos, para que sea más fácil entender el código. Por ejemplo, si queremos almacenar el nombre de un usuario, podemos utilizar el identificador nombreDeUsuario o bien username. En cambio, si queremos almacenar el número de intentos de un usuario, podemos utilizar el identificador numeroDeIntentos o bien attempts.

Veremos que existen ciertas convenciones para nombrar variables, las cuales son recomendadas por Oracle. Estas convenciones se encuentran en Code Conventions for the Java Programming Language.

Por último, existirán casos en los que necesitemos declarar variables “temporales”, las cuales utilizaremos para realizar algún cálculo o para almacenar un valor por un corto período de tiempo. En estos casos, es recomendable utilizar nombres de una sola letra, como i, j, k, m o n para números enteros, o c, d o e para caracteres.

Tipos de datos primitivos

Como podemos notar, será imprescindible conocer los tipos de datos que podemos utilizar en Java para poder programar adecuadamente. En Java, existen tres tipos de datos, los primitivos, los estructurados o clases y los wrappers.

Por el momento estudiaremos los tipos de datos primitivos, los cuales podemos clasificar a su vez en cuatro categorías: numéricos enteros, numéricos de punto flotante, caracteres y booleanos.

Tipos de datos primitivos

Figura 1: tipos de datos primitivos

Numéricos enteros

Los tipos de datos numéricos enteros son aquellos que pueden almacenar números enteros, es decir, números sin parte decimal. Estos tipos de datos son byte, short, int y long, y se diferencian entre sí por el rango de valores que pueden almacenar.

Tipo de dato	Tamaño	Rango
`byte`	8 bits	-128 a 127
`short`	16 bits	-32.768 a 32.767
`int`	32 bits	-2.147.483.648 a 2.147.483.647
`long`	64 bits	-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807

Numéricos de punto flotante

Los tipos de datos numéricos de punto flotante son aquellos que pueden almacenar números con parte decimal. Estos tipos de datos son float y double, y se diferencian entre sí por el rango de valores que pueden almacenar.

Tipo de dato	Tamaño	Rango
`float`	32 bits	1.40129846432481707e-45 a 3.40282346638528860e+38
`double`	64 bits	4.94065645841246544e-324d a 1.79769313486231570e+308d

Caracteres

El tipo de dato char es el único tipo de dato que puede almacenar caracteres. Este tipo de dato es de 16 bits, y puede almacenar cualquier carácter Unicode.

Pueden encontrar más información sobre Unicode en Unicode.

Booleanos

El tipo de dato boolean es el único tipo de dato que puede almacenar valores booleanos. Este tipo de dato es de 1 bit, es decir, puede tomar dos valores: false y true.

Strings

A pesar de que String no es un tipo de dato primitivo, es un tipo de dato muy utilizado en Java. Si bien analizaremos más en detalle las clases más adelante, queremos mencionar a String dada su gran utilidad.

El tipo de dato String permite almacenar cadenas de caracteres, a diferencia del tipo de dato char, que solo puede almacenar un carácter.

Para definir una variable de tipo String, debemos utilizar la palabra reservada String y asignarle un identificador.

1
String nombre;

Para asignarle un valor a una variable de tipo String, debemos utilizar el operador de asignación (=) y escribir un literal de cadena de texto entre comillas dobles ("). En el primer ejemplo que vimos, utilizamos el método mostramos el mensaje Hola Mundo! en la consola, el cual es un literal de cadena de texto.

1
System.out.println("Hola Mundo!");

Al igual que cualquier otra expresión, podemos almacenar un literal de cadena de texto en una variable de tipo String y luego utilizarla.

De momento, no entraremos en detalle sobre los métodos de la clase String, ya que los estudiaremos más adelante.

Asignación de variables

Una vez que declaramos una variable, podemos asignarle un valor. Para asignar un valor a una variable, debemos utilizar el operador de asignación (=), respetando el tipo de dato de la variable.

<nombre_de_variable> = <valor>;

Por ejemplo, si queremos asignar el valor 5 a la variable numero de tipo int, debemos escribir:

1
int numero;
2
numero = 5;

También podemos declarar y asignar un valor a una variable en una sola línea, utilizando el operador de asignación (=).

<tipo_de_dato> <nombre_de_variable> = <valor>;

Para el ejemplo anterior, podemos emplear la siguiente sentencia:

1
int numero = 5;

Ambas sentencias son equivalentes, y podemos utilizar cualquiera de las dos para asignar un valor a una variable.

Por supuesto, podemos asignar un valor a una variable en cualquier momento, siempre y cuando la variable haya sido declarada previamente.

Por ejemplo, podemos declarar una variable de tipo char y asignarle un valor en una línea, y luego asignarle otro valor en otra línea.

1
char letra;
2
letra = 'a';
3
letra = 'b';

De igual manera, podemos realizar este proceso con cualquier tipo de dato.

1
float numero;
2
numero = 3.14f;
3
numero = 2.71f;

1
boolean encendido;
2
encendido = true;
3
encendido = false;

Constantes

Las constantes, como lo indica su nombre, son variables cuyo valor no puede ser modificado durante la ejecución del programa. Para declarar una constante, debemos utilizar la palabra reservada final antes del tipo de dato y asignarle un valor.

1
final int numero = 5;

En este caso, la variable numero es una constante de tipo int cuyo valor es 5. Si intentamos modificar el valor de la constante, el compilador nos mostrará un error.

1
final int numero = 5;
2
numero = 6; //error: cannot assign a value to final variable numero