Conversión de tipos en Java: ampliación, reducción y conversiones

Qué significa la conversión de tipos

Java es de tipado estático: cada valor tiene un tipo, y el compilador no te dejará mezclar tipos incompatibles de forma silenciosa. La conversión de tipos es la manera de convertir un valor de un tipo a otro: a veces Java lo hace por ti, y a veces tienes que pedirlo explícitamente.

Hay dos direcciones. Pasar de un tipo más pequeño a uno más grande (un int a un double) es seguro y ocurre de forma automática. Pasar de un tipo más grande a uno más pequeño (un double a un int) puede perder datos, así que Java te obliga a indicarlo con una conversión.

Ampliación: la conversión automática

Una conversión de ampliación mueve un valor a un tipo con más espacio. No se puede perder nada, así que Java lo hace por ti sin necesidad de una conversión:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automático

        System.out.println(price);   // 7.0
    }
}

El int 7 encaja en un double y se convierte en 7.0. El orden de ampliación para los números es byte -> short -> int -> long -> float -> double; asignar de izquierda a derecha a lo largo de esa cadena nunca necesita una conversión. Por eso mezclar tipos en operaciones aritméticas suele "funcionar sin más": Java amplía primero el operando más pequeño.

Reducción: la conversión explícita

En el otro sentido —una conversión de reducción— se pueden perder datos, así que el compilador se niega a menos que pongas el tipo de destino entre paréntesis delante del valor:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // conversión de reducción explícita

        System.out.println(whole);   // 3, no 4
    }
}

(int) pi es la conversión. Fíjate en lo que hace: trunca hacia cero, simplemente descartando la parte decimal. 3.9 se convierte en 3, y -3.9 en -3. No redondea. Si quieres redondear, esa es otra herramienta distinta:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (trunca)
        System.out.println(Math.round(value));    // 4  (redondea)
    }
}

Olvidar que una conversión trunca es uno de los errores más comunes entre principiantes: si tu número "redondeado" siempre sale uno menos, normalmente esta es la razón.

La trampa de la división entera

Este detalle nos pilla a todos alguna vez. Cuando ambos operandos son int, el operador / realiza una división entera y descarta el resto —antes de cualquier asignación a un double—:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - ¡la división se hace primero como ints!
        double right = (double) a / b; // 3.5  - convierte un operando primero

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b es 7 / 2, calculado por completo con aritmética de int, lo que da 3. Ampliar a double después solo convierte 3 en 3.0: el .5 ya se ha perdido. Convertir un operando a double primero ((double) a / b) fuerza toda la expresión a coma flotante, dando el 3.5 que querías. Solo necesitas convertir un lado; Java amplía el otro para que coincida.

Cuándo la reducción desborda

Una conversión no comprueba si el valor cabe. Si no cabe, los bits simplemente se recortan y obtienes un resultado sorprendente: sin error, sin advertencia:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte solo admite -128..127

        System.out.println(small);   // 44, no 300
    }
}

300 no cabe en un byte, así que se descartan los bits altos y obtienes 44. Esta es una pérdida de datos "silenciosa": el programa se ejecuta bien y da una respuesta incorrecta. Reduce solo cuando estés seguro de que el valor cabe en el tipo más pequeño.

Conversión entre números y cadenas

Un String es un objeto, no un número, así que no puedes convertirlo con (int): eso es un error de compilación. La conversión usa métodos dedicados en su lugar:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Para pasar de texto a número se usa Integer.parseInt / Double.parseDouble. Si la cadena no es un número válido (por ejemplo "hello"), estos métodos lanzan una NumberFormatException. Para pasar de un número a texto, usa String.valueOf(n) o simplemente concatena con "", porque n + "" fuerza el int a convertirse en un String. Cuidado con la diferencia entre "5" + 1 (que da la cadena "51") y 5 + 1 (que da 6); el + significa concatenación en cuanto interviene un String.

Conversión de objetos

La conversión también se aplica a las referencias de objetos, no solo a los primitivos. Puedes convertir una referencia a un tipo relacionado a lo largo de una cadena de herencia: ampliar a un tipo padre es automático, mientras que reducir de nuevo requiere una conversión explícita y solo es seguro si el objeto realmente es de ese tipo:

Object o = "hello";
String s = (String) o;        // OK: o realmente apunta a un String
Integer bad = (Integer) o;    // compila, pero lanza ClassCastException en tiempo de ejecución

La segunda conversión compila, pero falla en tiempo de ejecución con una ClassCastException porque el objeto es un String, no un Integer. Verás esto en detalle cuando llegues a la herencia y el polimorfismo; por ahora, solo debes saber que la sintaxis (Type) es la misma idea aplicada a los objetos.

Siguiente: if-else

La conversión te permite reformar valores; el siguiente paso es hacer que tu programa elija entre caminos según esos valores. La sentencia if-else ejecuta un bloque cuando una condición es verdadera y otro cuando es falsa: el fundamento de toda decisión que tome tu código. Esa es la siguiente página.