Programación en Java/Operador cast

Cada vez que realizamos una operación obtenemos un resultado. Este resultado podrá tener un tipo de dato diferente de los operandos. Veamos esto:

public class CambioTipo {
   public static void main(String args[]){
          byte unByte = 2;
          byte otroByte = 3;
          byte result = unByte + otroByte;
   }
} 

Nos da un error en la compilación. Se debe a que se produjo un cambio de tipo en el resultado, en vez de un byte se nos apareció un int. Este es un cambio de tipo implícito.

Pero no queremos que quede así. Podemos forzar al compilador que nos entregue un byte. Lo haremos de la siguiente forma :

byte result = (byte)(unByte + otroByte);

Estamos realizando un cambio explícito de tipo, realizado con un operador cast. Este operador aparece como el nombre del tipo a obtener entre paréntesis; siempre antepuesto al resultado que se debe modificar.

Nos encontraremos ahora con un viejo conocido que nos ha molestado antes, es el literal descarriado:

float f = 3.14; 

Sabemos ya que nos dará un error debido a que es un literal double que trata de disfrazarse de float. Pero le daremos un cast así lo transformamos en float.

float f = (float)3.14;

De esta manera el compilador no protestará porque colocamos peras con manzanas. El operador cast se ocupó de convertir un double en un float.

Existe un cierto peligro en la utilización indiscriminada de este operador. Observemos el siguiente programa :

public class Int2Byte {
   public static void main(String args[]){
          int  unInt = 5000;
          byte unByte = (byte)unInt;
          System.out.println("el resultado es : " + unByte);
   }
}

Aquí intentamos meter a empujones un valor en un byte, cuyo valor es más grande de lo soportado. Pero en este caso Java tomas las cosas con indiferencia. Si ejecutamos el programa nos indicará :

el resultado es : -120

El resultado dista mucho del valor original. El operador cast se comportó como una picadora de bits. Si miramos con lupa ambos valores, nos damos cuenta de qué ocurrió:

00000000000000000001001110001000 : un int de valor 5000 
                        10001000 : un byte de valor -120, complemento a 2

Resulta que al aplicar el cast "cortamos" la variable int en los primeros 8 bits que corresponden al tamaño del byte.