Conversión de tipos Java

¿Qué es la conversión de tipos en Java?

Un tipo de datos es un conjunto predefinido de valores que especifican el tipo de valores que se pueden almacenar en él junto con la operación que se puede realizar sobre ellos. La conversión de tipos de Java es un proceso mediante el cual un tipo de datos se convierte en otro. Puede ser tanto implícito como explícito . El compilador realiza el encasillamiento implícito, también conocido como encasillamiento automático. El encasillamiento explícito lo realiza manualmente el programador en el código.

¿Por qué se requiere la fundición tipográfica?

Java tiene diferentes tipos de datos primitivos que requieren diferentes espacios en la memoria. Esto puede causar problemas de compatibilidad al asignar un valor de un tipo de datos a otro. Si los tipos de datos ya son compatibles, el compilador realiza la conversión automáticamente. Por lo tanto, el encasillamiento resuelve un importante problema de compatibilidad cuando se trata de diferentes tipos de datos en nuestro programa.

Tipos de conversión de tipos de Java

Hay dos tipos de conversión de tipos en Java.

1. Conversión de tipo ampliada : también conocida como conversión de tipo implícita o automática
2. Conversión de tipo estrecha : también conocida como conversión de tipo explícita o manual

Fundición tipo ampliación

El encasillamiento ampliado, como sugiere el nombre, se refiere a la ampliación de un tipo de datos más pequeño a un tipo de datos más grande. Realizamos este encasillamiento cuando queremos convertir un tipo pequeño en un tipo grande. Los tipos de datos deben ser compatibles entre sí. No hay ninguna conversión implícita de tipo numérico a char o booleano. En Java, los tipos char y boolean no son compatibles. Este tipo de conversión lo realiza automáticamente el compilador sin pérdida de información. No requiere ningún disparador externo por parte del programador.

Ejemplo

//Automatic type conversion
public class WideningExample {
   public static void main(String[] args) {

       int i = 100;
       System.out.println("int value: " + i);

       // int to long type
       long l = i;
       System.out.println("int to long value: " + l);

       // long to float type
       float f = l;
       System.out.println("int to float value: " + f);


       byte b = 1;
       System.out.println("byte value: " + b);

       // byte to int type
       i = b;
       System.out.println("byte to int value: " + i);

       char c = 'a';
       System.out.println("char value: " + c);

       // char to int type
       i = c;

       // prints the ASCII value of the given character
       // ASCII value of 'a' = 97
       System.out.println("char to int value: " + i);
   }
}

Producción

Explicación

En el código anterior, hemos mostrado el encasillamiento ampliado que el compilador realiza automáticamente. En primer lugar, asignamos valores a int , byte y char . Luego asignamos los valores int a long y float , los cuales son mayores que int . También asignamos los valores de byte y char a int . Tanto byte como char son tipos de datos más pequeños que int , por lo que estas conversiones fueron implícitas.

Fundición de tipo estrechamiento

El encasillamiento restringido, como su nombre indica, se refiere a la reducción de un tipo de datos más grande a un tipo de datos más pequeño. Realizamos este encasillamiento cuando queremos convertir un tipo grande en un tipo pequeño. Para este tipo de conversión, anulamos la conversión predeterminada de Java especificando nuestra propia conversión. Para lograr esto, escribimos la variable o valor que debe encasillarse precedido por el tipo de datos de destino entre paréntesis '()'. Sin embargo, este tipo de fundición puede provocar una posible pérdida de precisión.

Ejemplo

//Manual Type Conversion
public class NarrowingExample {
   public static void main(String[] arg) {

       // double data type
       double d = 97.04;
       // Print statements
       System.out.println("double value: " + d);

       // Narrowing type casting from double to long
       // implicitly writing the target data type in () followed by initial data type
       long l = (long) d;

       // fractional part lost - loss of precision
       System.out.println("long value: " + l);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       int i = (int) l;

       // fractional part lost - loss of precision
       System.out.println("int value: " + i);

       // Narrowing type casting from double to int
       // implicitly writing the target data type in () followed by initial data type
       char c = (char) i;

       // displaying character corresponding to the ASCII value of 100
       System.out.println("char value: " + c);
   }
}

Producción

Explicación

El programador debe realizar explícitamente el encasillamiento restringido utilizando una sintaxis estándar. En el programa anterior, comenzamos con un valor doble que es mayor que los tipos de datos long e int . Encasillamos este double en long e int usando paréntesis con los tipos de datos de destino deseados. También hemos encasillado manualmente 'int' a 'char'.

Conclusión

Al final de esta publicación, esperamos que se haya familiarizado en detalle con Java Type Casting. Ha aprendido los dos tipos de encasillamiento en Java. También ha aprendido cómo convertir manualmente los tipos de datos no compatibles utilizando el encasillamiento de estrechamiento. Puede probar otras combinaciones de tipos de datos con diferentes valores por su cuenta para comprenderlo con más profundidad. Continúe practicando para obtener un dominio más profundo del concepto. Hasta entonces, ¡sigue creciendo y sigue brillando!