Casting en Java: qué es y para qué sirve

El casting es un recurso en programación que nos permite transformar un valor o el contenido de una variable de un tipo a otro. Sin embargo debes tener cuidado. Es importante que se cumplan ciertas reglas de compatibilidad.

Para hacer un casting sólo necesitas poner delante, entre paréntesis, el tipo al que quieres convertir una expresión, y después la propia expresión (un valor, una variable, una operación, etc.).

Puedes copiar este código y pegarlo en un archivo que se llame i_Casting.java dentro del paquete A_Inicio para comprobar su funcionamiento.

/* Aprendiendo a programar en DAM con elProfesorEmilio */
package A_Inicio;

/**
 * @author elProfesorEmilio
 * Hacer un casting en Java es forzar la conversión de un valor de un tipo
 * a otro tipo que sea compatible. Es necesario que sea compatible, si no
 * no es posible hacer un casting. 
 */
public class i_Casting {

    public static void main(String[] args) {
        // Definimos una variable double y la inicializamos
        double d = 1.9;
        /* 
        Ahora definimos una variable entera y la inicializamos al valor de d
        NOTA: Para poder convertir un double a int se pierde la parte entera        
        */
        int i = (int)d;
        System.out.println(i);
        /*
        Date cuenta que no se redondea, se queda con la parte entera
        Igualmente, si tratamos de usar un número más grande de lo que 
        admite un int, perderemos información
        */
        d = Double.MAX_VALUE; // Asignamos el mayor double posible
        i = (int)d; // Al convertir se pierde gran parte de información
        System.out.println(d+"->"+i);
        
        // Lo mismo pasa con float y double, aunque float puede contener
        // más información que un int
        float f = (float)d;
        // Fíjate bien en lo que escribe ahora al haber hecho esa conversión
        System.out.println(d+"->"+f);
        // Sin embargo, si ponemos valores razonables no hay problema
        d = 252345.23;
        f = (float)d;
        System.out.println(d+"->"+f);
        
        // Prueba a descomentar el siguiente código y verás qué cosa más curiosa
        /*
        d = 252345.24;
        f = (float)d;
        System.out.println(d+"->"+f);
        */
        /*
        ¿Te has fijado en esta parte? 
        ¿Entiendes por qué no se pueden usar double y float para manejar dinero? 
               
        En el caso siguiente, como hay demasiados decimales para un float
        el cambio de tipo lleva implícito un redondeo
        */
        d = 252345.24312345234;
        f = (float)d;
        System.out.println(d+"->"+f);
        
        /* 
        Vamos ahora a convertir a cadena
        El siguiente es un truco poco ortodoxo que funciona
        al intentar 'concatenar' una cadena vacía "" con un número
        */
        
        String s = ""+i;
        // Lo siguiente será más correcto
        String masCorrecto = String.valueOf(d);
        
        // Ejemplos de más cambios en los que se pierde información si
        // no andas con cuidado
        short enteroCorto = (short)i;
        long l = 3323423842393423645l;
        i = (int)l;
        
        /*
        Insisto, cuidado con la pérdida de información
        Podemos convertir un número en un char, pero ten en cuenta
        que un char sólo puede almacenar 2 bytes
        */
        char c = (char)d;
        System.out.println((int)c);
        
        // Ejemplos de cosas que no se pueden hacer, trata de quitar comentarios
        boolean b;
        // s = (String)i;
        // b = (boolean)i;
        // b = (boolean)s;
        // Aunque sí se podría hacer
        b = Boolean.valueOf(s); 
        // Esto sin embargo puede dar un valor no esperado
        System.out.println(b);
        // Lo siguiente es más lógico
        b = Boolean.valueOf("true"); 
        System.out.println(b);
        
        // Prueba tú a crear variables de distintos tipos y a
        // tratar de hacer las conversiones que se te ocurra
    }
}