Conversión de tipos en Java

La conversión de tipos consiste en transformar un valor de un tipo a otro. En Java esto ocurre de dos maneras: las conversiones de ensanchamiento, que se producen automáticamente y nunca pierden información, y las conversiones de estrechamiento, que requieren un cast explícito y pueden perder datos.

Conversión de ensanchamiento (implícita)

Una conversión de ensanchamiento mueve un valor hacia un tipo más grande. El compilador lo hace de forma automática — no se necesita ninguna sintaxis especial:

int i = 100;
long l = i;        // int → long (widening)
double d = l;      // long → double (widening)

System.out.println(i);   // 100
System.out.println(l);   // 100
System.out.println(d);   // 100.0

El orden estándar de ensanchamiento es:

byte → short → int → long → float → double
              char ↗

(char se ensancha a int y en adelante, pero no a short ni a byte.)

El ensanchamiento nunca pierde rango — un long siempre cabe en el rango de un double, aunque double no pueda representar exactamente todos los valores long. Presta atención a esa brecha de representación exacta en valores extremos.

Cast de estrechamiento (explícito)

Una conversión de estrechamiento mueve un valor hacia un tipo más pequeño. Java se niega a hacerlo implícitamente porque se pueden perder datos. Debes indicarlo explícitamente con (targetType):

double d = 9.99;
int i = (int) d;   // explicit narrowing cast

System.out.println(i);   // 9 — the fractional part is dropped

El cast trunca hacia cero — no redondea.

Para enteros, un cast conserva solo los bits de orden inferior:

int big = 130;
byte b = (byte) big;
System.out.println(b);   // -126 — overflow wraps around

byte tiene 8 bits, con rango -128…127. Los bits de 130 (10000010) se interpretan como -126 en complemento a dos.

Un cast habitual: división entera a número real

La aritmética entera pura usa división entera — 5 / 2 == 2, no 2.5. Para obtener un resultado real, castea al menos un operando antes de la división:

int total = 5;
int count = 2;

double avgWrong = total / count;          // 2.0 — division is still integer
double avgRight = (double) total / count; // 2.5 — total widened first

Esta es la razón más común por la que se recurre a un cast.

Casts de referencia

La sintaxis (Type) también funciona con objetos — aunque ahí es una comprobación en tiempo de ejecución, no una conversión. Castear una referencia es esencialmente decir "confía en mí, este objeto es de tipo X":

Object o = "Hello";
String s = (String) o;            // OK at runtime
System.out.println(s.length());   // 5

Object n = Integer.valueOf(7);
String bad = (String) n;          // throws ClassCastException at runtime

Para castear una referencia de forma segura, comprueba primero el tipo con instanceof:

Object o = "Hello";
if (o instanceof String) {
    String s = (String) o;        // guaranteed safe
    System.out.println(s.length());
}

La coincidencia de patrones para instanceof (Java moderno) permite hacer la comprobación y el cast en un solo paso. Los casts de referencia se tratan en detalle en POO y Polimorfismo.

Un ejemplo funcional

Cuando el compilador "ayuda" — y cuando no

Un caso sutil a tener en cuenta: la aritmética con byte, short o char se promueve automáticamente a int antes de la operación. El resultado es un int:

byte a = 10;
byte b = 20;
// byte sum = a + b;       // compile error: result is int
byte sum = (byte) (a + b);  // explicit cast needed

Esto le ocurre a todo el mundo la primera vez. Guarda el resultado en int, o haz un cast de vuelta.

Reglas prácticas

• Ensancha libremente — no se necesita cast, no hay pérdida.
• Estrecha con un cast y una verificación — asegúrate de que el valor realmente cabe.
• Para la división con resultado real entre enteros, castea un operando a double.
• Para cálculos monetarios, no uses double — usa BigDecimal para evitar errores de redondeo en coma flotante binaria.

Qué viene a continuación

Operadores de Java — la visión completa de todos los operadores que incluye el lenguaje.

Práctica