Tipos de datos en Java: primitivos, tipos de referencia y valores por defecto

Dos familias: primitivos y referencias

Todo valor en Java tiene un tipo, y ese tipo pertenece a una de dos familias. Los tipos primitivos almacenan un valor crudo directamente: un número, un único carácter o un verdadero/falso. Los tipos de referencia almacenan una referencia (un puntero) a un objeto que vive en otra parte de la memoria: String, los arreglos y todas las clases que tú o las bibliotecas definís.

La distinción importa porque los primitivos son ligeros y se copian por valor, mientras que las variables de referencia apuntan a objetos compartidos. Empieza por los ocho primitivos: son la base sobre la que se construye todo lo demás.

Los ocho tipos primitivos

Java tiene exactamente ocho tipos primitivos integrados. Seis son números, uno es un carácter y uno es un booleano:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // entero de 8 bits,  -128 .. 127
        short  s = 30000;        // entero de 16 bits
        int    i = 2_000_000;    // entero de 32 bits (el valor por defecto para enteros)
        long   big = 9_000_000_000L; // entero de 64 bits - fíjate en la L

        float  f = 3.14f;        // decimal de 32 bits - fíjate en la f
        double d = 3.141592653589793; // decimal de 64 bits (el valor por defecto para decimales)

        char   c = 'A';          // un único carácter Unicode de 16 bits
        boolean flag = true;     // solo true o false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Algunas cosas que conviene notar desde el principio: los guiones bajos en 2_000_000 son solo separadores visuales que el compilador ignora, los sufijos L y f son obligatorios (más sobre esto abajo), y char usa comillas simples mientras que un String usaría comillas dobles.

Cómo elegir un tipo numérico

Casi nunca necesitas byte ni short: solo ahorran memoria en arreglos enormes. Las decisiones reales están entre int/long para enteros y float/double para decimales.

Tipo	Tamaño	Úsalo cuando
int	32 bits	El valor por defecto para enteros (hasta ~2.100 millones)
long	64 bits	Valores por encima de ~2.000 millones: marcas de tiempo en milisegundos, tamaños de archivo
double	64 bits	El valor por defecto para decimales - buena precisión
float	32 bits	Solo cuando la memoria es escasa y la precisión puede resentirse

La trampa es el desbordamiento. Un int se enrolla silenciosamente cuando supera su rango: ningún error, solo una respuesta equivocada:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // ¡se enrolla a un número negativo!

        long safe = (long) maxInt + 1;  // primero lo promovemos a long
        System.out.println(safe);
    }
}

maxInt + 1 se desborda a -2147483648 porque ambos operandos son int y el resultado sigue siendo un int. Convertir un lado a long primero hace el cálculo en 64 bits. Cuando un valor puede ser grande - especialmente los milisegundos desde 1970 - recurre a long.

Literales y sus sufijos

Un literal numérico simple tiene un tipo por defecto, y eso causa problemas. 100 es un int; 3.14 es un double. Para escribir un literal long o float debes añadir un sufijo:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // sin la L esto es demasiado grande para int -> error
        float ratio = 0.5f;               // sin la f el lado derecho es un double -> error
        double pi = 3.14;                 // bien - los decimales son double por defecto

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Quita la L de 8_000_000_000L y el código no compilará, porque el literal supera el rango de int antes de llegar siquiera a la variable long. Quita la f de 0.5f y Java se queja de que un double no puede asignarse a un float sin una conversión. El sufijo no distingue entre mayúsculas y minúsculas, pero usa la L mayúscula: una l minúscula se parece exactamente al dígito 1.

char es un número disfrazado

Un char almacena una unidad de código Unicode de 16 bits, lo que significa que funciona también como un pequeño entero sin signo. Puedes hacer aritmética con él y convertirlo de ida y vuelta con una conversión:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - el valor Unicode de 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Esto resulta útil de vez en cuando para desplazar letras, pero no te apoyes en ello para manejar texto: para eso está String. Ten en cuenta que char usa comillas simples ('A'); las comillas dobles ("A") crean un String de un solo carácter, que es un tipo completamente distinto.

Valores por defecto (y la trampa de las variables locales)

Los campos y los elementos de arreglos que no inicializas reciben un valor por defecto razonable. Pero esto solo se aplica a los campos y las posiciones de los arreglos: las variables locales no reciben ningún valor por defecto, y usar una antes de asignarle un valor es un error de compilación, no una sorpresa en tiempo de ejecución.

public class Main {
    static int counter;        // campo -> por defecto 0
    static boolean ready;      // campo -> por defecto false
    static String name;        // campo -> por defecto null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // los elementos del arreglo por defecto son 0
        System.out.println(nums[0]); // 0
    }
}

Si en cambio escribieras int x; System.out.println(x); dentro de main, el compilador lo rechazaría con "variable x might not have been initialized". Esa rigurosidad es una ventaja: te impide leer basura. Los valores por defecto a recordar: los tipos numéricos 0, boolean false, char ' ' y todo tipo de referencia null.

A continuación: Strings

String es el tipo de referencia que más vas a usar: texto, valores unidos, entrada del usuario. Se comporta de forma distinta a los primitivos vistos aquí: es un objeto, es inmutable y comparar cadenas tiene sus propias trampas. La siguiente página lo cubre.