Tipos primitivos · JavaGod

Ocho tipos, y solo ocho

Java es de tipos estáticos: cada variable declara qué guarda, y eso no cambia nunca. De todo lo que existe en el lenguaje, solo ocho tipos no son objetos. Todo lo demás, incluido String, es una referencia.

Las cuatro familias

01 Enteros con signo byte short int long Complemento a dos: hay negativos.
02 Carácter char Entero sin signo, 16 bits.
03 Coma flotante float double IEEE 754, con sus rarezas.
04 Lógico boolean Solo true o false.

Los tres primeros grupos son numéricos. boolean no lo es, y la especificación de la máquina virtual no le fija un tamaño.

Cuánto ocupa cada uno

Tipo	Bits	Rango	Cuándo usarlo
`byte`	8	`-128` a `127`	Datos binarios y ahorro de memoria en arrays grandes
`short`	16	`-32_768` a `32_767`	Casi nunca: `int` es más simple
`int`	32	`-2_147_483_648` a `2_147_483_647`	El entero por defecto
`long`	64	`-9_223_372_036_854_775_808` a `9_223_372_036_854_775_807`	Tiempos en milisegundos, tamaños enormes
`float`	32	IEEE 754, precisión simple	Gráficos y cálculo aproximado
`double`	64	IEEE 754, precisión doble	Cálculo científico, no dinero
`char`	16	`0` a `65_535`	Un carácter Unicode en UTF-16
`boolean`	sin definir	`true` o `false`	Cualquier condición

El tamaño de boolean no está fijado porque la máquina virtual decide cómo lo representa: la especificación habla de codificaciones, no de bits.

Cómo se escriben los literales

Un número entero escrito en el código es un int por defecto. Para que sea long lleva sufijo L. Desde Java 7 puedes agrupar dígitos con guiones bajos y escribir en binario:

java

int millones = 1_000_000;
long distancia = 384_400_000L;
int binario = 0b1010_0001;
int hexadecimal = 0xFF_FF;
double precio = 19.99;
float presion = 1013.25f;

Los guiones bajos no cambian el valor: existen para que el ojo cuente cifras.

Cuando el número se pasa de vuelta

Los enteros de Java dan la vuelta en silencio. No hay excepción, no hay aviso: sumar uno al máximo de un int devuelve el mínimo.

java

int maximo = Integer.MAX_VALUE;   // 2_147_483_647
int roto = maximo + 1;            // -2_147_483_648
int controlado = Math.addExact(maximo, 1); // ArithmeticException

Si el desbordamiento es un error de tu programa, Math.addExact y compañía convierten el silencio en una excepción que puedes tratar.

Dividir no siempre da lo que esperas

Con enteros, la división trunca hacia cero y el resto se descarta. Dividir un int entre cero lanza ArithmeticException. Con double, dividir entre cero no falla: da infinito.

java

System.out.println(7 / 2);        // 3
System.out.println(7 % 2);        // 1
System.out.println(7.0 / 0.0);    // Infinity
System.out.println(0.0 / 0.0);    // NaN

char es un número

char guarda una unidad de código UTF-16 y se escribe entre comillas simples. En una operación aritmética se promociona a int:

java

char letra = 'A';
int codigo = letra + 1;      // 66
char siguiente = (char) codigo; // 'B'

String, en cambio, va con comillas dobles y es un objeto: lo suyo es un capítulo aparte.

Qué te llevas

int es el entero por defecto; elige long cuando el rango de int no alcance.
El desbordamiento es silencioso. Si importa, usa Math.addExact o long.
La coma flotante es aproximada. El dinero no se representa con float ni con double.
char es numérico, pero no es un entero cualquiera: se promociona a int y necesita conversión para volver.