1.10 Conversiones de Tipos de Datos (cast)

Para que el resultado sea el esperado hay muchas ocasiones que es necesario realizar alguna conversión de tipos.

Java emplea siempre que puede la representación en forma int de 32 bits, por razones de eficacia, por lo tanto permite la conversión automática o promoción donde el tipo más pequeño puede ser colocado en el espacio compatible más grande, así un tipo byte, puede ser colocado perfectamente en una variable int, la cual tiene espacio para contener el valor. Lo contrario no siempre es cierto y se hace necesaria una conversión explícita, estrechamiento o casting:

Int a=100;

byte b= (byte) a;

El casting se utiliza cuando Java no puede realizar automáticamente la conversión de tipo, generalmente dado que el receptor tiene menos espacio que el tipo de origen, por lo que se hace necesario un casting.

El casting, pues, es la conversión explícita y se realiza anteponiendo al tipo origen el nombre del tipo al que se desea realizar la conversión entre paréntesis:

int intValue= (int) floatValue;

El casting es automático desde los tipos de pequeña ocupación a los de gran ocupación:

longValue=intValue;  /** Permitido. El tipo convertido es menor que el tipo hacia el que se convierte.*/

longValue= (int) intValue;  /** Escrito de forma explícita, no necesario para este caso, pero correcto */

Sin embargo si se quiere hacer la conversión a un tipo más pequeño:

intValue=longValue;  /** El compilador nos lanzaría un error*/

intValue=(int) longValue;  /** Esta permitido, sin embargo corremos el riesgo de perdida de datos*/

En las operaciones pueden entremezclarse cualesquiera tipos decimales, pero el resultado se promociona a un tipo que no dé problemas de desbordamiento:

–          Si solo intervienen tipos byte, short, int el resultado es int.

–          Si interviene un tipo long el resultado es long.

–          Si interviene un tipo float el resultado es float.

–          Si interviene un tipo double el resultado es double.

Ejemplo: Creamos un programa llamado ConversionImplicita en la que se declaren variables de tipo byte, char, short, int, float, y double, y se realizan las siguientes operaciones:

1.-Resul1 = Multiplicamos el valor float con el valor byte.

2.-Resul2 =Dividimos el valor int con el valor char.

3.-Resul3 =Multiplicamos el valor double con el valor short.

4.-Resul4 =Dividimos el valor int con el valor char.

5.-ResulTotal = Resul1 + Resul2 + Resul3 + Resul4

6.-Y lo mostramos por pantalla.

class ConversionImplicita {

     public static void main(String[] args){

     byte sByte=50;

     char sChar=”a”;

     short sShort=1024;

     int sInt=50000;

     float sFloat=5.57f;

     double sDouble=.1234;

// Conversión Implicita o Automática

     float Result1= sFloat*sByte;

     int Result2= sInt/sChar;

     double Result3= sDouble*sShort;

// Conversion Explicita o Forzada

     double Result4= (double) (sInt/schar);

     double ResultTotal= Result1 + Result2+ Result3+ Result4;

     system.out.print(“el valor total es: “);

     system.out.println(Result4);

}}

Cabe destacar en este ejercicio el uso de la variable char como entero. Esto es debido a que una variable char es equivalente al valor entero de dicho carácter en la tabla ASCII, en este caso la letra ‘a’ corresponde con el valor 97.