Continuando con el curso de programación, en esta ocasión nos metemos de lleno en comprender cómo funciona mediante un recurso extremadamente importante: Las variables. Para ello, seguiremos con nuestra técnica de programar en Java.

En todos, absolutamente todos los lenguajes de programación existen las variables. Estas no son otra cosa que datos que guardamos para usarlos más adelante. Es decir, si queremos contar manzanas, deberemos llevar la cuenta. Esa «cuenta» sería una variable, y cada vez que contamos una nueva manzana, le añadiríamos 1.

Las variables, como su nombre indica, varían. Es decir, que no tienen por qué tener el mismo valor al principio del programa que entre medias o al final. Podemos por ejemplo, empezar la cuenta de las manzanas en 0, y si consultáramos el valor de la variable sería 0, y al final del programa tener 5 en la cuenta.

Comencemos con un ejemplo básico para entenderlo, crearemos la clase Manzanas en Eclipse:

public class Manzanas {
    public static void main(String[] args) {
        int cuenta = 0; // Hemos encontrado una manzana
        cuenta = cuenta + 1; // Hemos encontrado otra manzana
        cuenta = cuenta + 1; // Esta es la última manzana
        cuenta = cuenta + 1;

        System.out.println("En total hemos encontrado " + cuenta + " manzanas");

        // Oh, parece que había una manzana más
        cuenta = cuenta + 1;

        System.out.println("Con la nueva son " + cuenta + " manzanas");
    }
}

Aunque todavía no entendamos bien este código, podemos ver que comenzamos con una cuenta de 0 manzanas, y cada vez que encontramos una le sumamos 1 a la cuenta actual. Y vemos como en un momento dado hay 3 manzanas, y posteriormente 4.

Vamos a explicar qué significa todo este código (solo la parte dentro del public static void main(String[] args)). Primero creamos una variable. En Java, y en todos los lenguajes de tipado estático las variables deben declararse antes de ser usadas, y deberemos decir qué tipo de variable es. En este caso será una variable que contendrá un entero (int) y la inicializaremos a 0. Es importante inicializar las variables, porque si no, podrían tener cualquier valor que tenga la memoria en ese momento. (aunque esto no es exactamente así, depende del lenguaje).

Una vez hecho eso, lo que hacemos es sumarle a la cuenta el valor 1. Y para eso usamos cuenta = cuenta + 1; que no es otra cosa que decirle, «la nueva cuenta es la cuenta actual más un uno». El punto y coma del final de todas las líneas es necesario en la mayoría de lenguajes de programación, para indicar que hemos acabado la sentencia. Suele ser un importante quebradero de cabeza, ya que es muy fácil olvidarlas.

Finalmente, imprimimos por pantalla una frase, usando el método System.out.println() del que enseñaré el funcionamiento más adelante.

En este caso hemos usado un tipo de variable entera (int) pero hay muchos tipos. Estos son los básicos y que se pueden encontrar prácticamente en todos los lenguajes de programación:

• Enteros (int) representan un número entero, como 0, 1, 2, etc. Puede tener valores positivos y negativos, desde -2147483648 a 2147483647. Ocupan 32 bits en memoria.
• Reales (double) representan un número real, con coma, como 0.1, 0.65, 56.98, etc. Puede tener valores positivos y negativos. Admite números enormes, pero su precisión no es exacta, es decir, que un 3 no será un 3, sino un 3.00000000000000000000001 o un 2.999999999999999999999. Es muy útil para representar números con coma. Ocupan 64 bits en memoria.
• Caracteres (char) son letras y números representados como texto, como ‘h’, ‘L’, ‘1’, etc. Ocupan 16 bits en memoria.
• Booleanos (boolean) representan un valor verdadero o falso.

Además de estos, podéis encontrar otros muchos en la documentación oficial. No obstante, son todos variaciones de los anteriores (long es un entero de 64 bits, podrás tener más números en el pero ocupará más RAM, etc). Mostraremos ahora su uso, creando para ello la clase Variables:

public class Variables {
    public static void main(String[] args) {
        int entero = 7;
        char caracter = 'J';
        double real = 6.8;
        boolean booleano = false;

        System.out.println("Nuestro entero es " + entero);
        System.out.println("Nuestro caracter es " + caracter);
        System.out.println("Nuestro real es " + real);
        System.out.println("Nuestro booleano es " + booleano);

        booleano = true;
        real = real-entero;
        caracter = 'L';

        System.out.println("Nuestro entero es " + entero);
        System.out.println("Nuestro caracter es " + caracter);
        System.out.println("Nuestro real es " + real);
        System.out.println("Nuestro booleano es " + booleano);
    }
}

En este caso, hemos creado 4 variables y las hemos modificado más adelante. Notad cómo hemos podido hacer una operación de resta entre un real y un entero, y aunque el resultado debería ser -0.2 hemos obtenido un número no tan preciso, en mi caso -0.20000000000000018.

No obstante, hay un tipo de datos, que aun sin ser primitivo es muy importante: la cadena de caracteres (String). Los strings son un conjunto de chars, que forman un texto. Se diferencian de los char porque se declaran como String y las comillas son dobles en lugar de simples:

public class Strings {

    public static void main(String[] args) {
        String cadena = "Esto es una cadena de caracteres";
        System.out.println(cadena);
    }
}

Si os habéis fijado, hasta ahora, todo lo que usábamos en los System.out.println() eran Strings. Es importante la mayúscula al principio. Esto es todo por ahora! Próximamente os enseñaré cómo realizar operaciones con los distintos tipos de datos. Hasta la próxima!