Conversión de tipos en Java con ejemplos

Java proporciona varios tipos de datos, probablemente cualquier otro lenguaje dinámico, como boolean, char, int, unsigned int, signed int, float, double, long, etc. En total, proporciona 7 tipos en los que cada tipo de datos adquiere un espacio diferente mientras se almacena en la memoria. Cuando asigna un valor de un tipo de datos a otro, es posible que los dos tipos no sean compatibles entre sí. Si los tipos de datos son compatibles, Java realizará la conversión automáticamente conocida como Conversión automática de tipos y, de no ser así, será necesario convertirlos explícitamente. Por ejemplo, asignar un valor int a una variable larga. 

Ampliación o conversión de tipo automática

La conversión de ampliación tiene lugar cuando dos tipos de datos se convierten automáticamente. Esto sucede cuando:  

• Los dos tipos de datos son compatibles.
• Cuando asignamos un valor de un tipo de datos más pequeño a un tipo de datos más grande.

Por ejemplo, en Java, los tipos de datos numéricos son compatibles entre sí, pero no se admite la conversión automática de tipo numérico a char o booleano. Además, char y boolean no son compatibles entre sí. 

Ejemplo:

// Java Program to Illustrate Automatic Type Conversion
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        int i = 100;
 
        // Automatic type conversion
        // Integer to long type
        long l = i;
 
        // Automatic type conversion
        // long to float type
        float f = l;
 
        // Print and display commands
        System.out.println("Int value " + i);
        System.out.println("Long value " + l);
        System.out.println("Float value " + f);
    }
}

Int value 100
Long value 100
Float value 100.0

Estrechamiento o Conversión Explícita

Si queremos asignar un valor de un tipo de datos más grande a un tipo de datos más pequeño, realizamos una conversión o estrechamiento de tipos explícitos.  

• Esto es útil para tipos de datos incompatibles donde no se puede realizar la conversión automática.
• Aquí, el tipo de destino especifica el tipo deseado para convertir el valor especificado.
   

char y number no son compatibles entre sí. A ver cuando tratamos de convertir uno en otro. 

// Java program to illustrate Incompatible data Type
// for Explicit Type Conversion
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] argv)
    {
 
        // Declaring character variable
        char ch = 'c';
        // Declaringinteger variable
        int num = 88;
        // Trying to insert integer to character
        ch = num;
    }
}

Salida: Se generará un error

Este error se genera cuando una variable entera toma 4 bytes mientras que el tipo de datos de carácter requiere 2 bytes. Estamos tratando de trazar datos de 4 bytes a 2 bytes, lo cual no es posible.

¿Cómo hacer una conversión explícita? 

// Java program to Illustrate Explicit Type Conversion
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Double datatype
        double d = 100.04;
 
        // Explicit type casting by forcefully getting
        // data from long datatype to integer type
        long l = (long)d;
 
        // Explicit type casting
        int i = (int)l;
 
        // Print statements
        System.out.println("Double value " + d);
 
        // While printing we will see that
        // fractional part lost
        System.out.println("Long value " + l);
 
        // While printing we will see that
        // fractional part lost
        System.out.println("Int value " + i);
    }
}

Double value 100.04
Long value 100
Int value 100

Nota: Al asignar valor al tipo de byte, la parte fraccionaria se pierde y se reduce al módulo 256 (rango de byte). 

Ejemplo:

// Java Program to Illustrate Conversion of
// Integer and Double to Byte
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Declaring byte variable
        byte b;
 
        // Declaring and initializing integer and double
        int i = 257;
        double d = 323.142;
 
        // Display message
        System.out.println("Conversion of int to byte.");
 
        // i % 256
        b = (byte)i;
 
        // Print commands
        System.out.println("i = " + i + " b = " + b);
        System.out.println(
            "\nConversion of double to byte.");
 
        // d % 256
        b = (byte)d;
 
        // Print commands
        System.out.println("d = " + d + " b= " + b);
    }
}

Conversion of int to byte.
i = 257 b = 1

Conversion of double to byte.
d = 323.142 b= 67

Escriba Promoción en Expresiones

Al evaluar expresiones, el valor intermedio puede exceder el rango de operandos y, por lo tanto, se promoverá el valor de la expresión. Algunas condiciones para la promoción de tipo son:  

1. Java promueve automáticamente cada operando byte, short o char a int al evaluar una expresión.
2. Si un operando es largo, flotante o doble, la expresión completa se promociona a largo, flotante o doble respectivamente.

Ejemplo:

// Java program to Illustrate Type promotion in Expressions
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Declaring and initializing primitive types
        byte b = 42;
        char c = 'a';
        short s = 1024;
        int i = 50000;
        float f = 5.67f;
        double d = .1234;
 
        // The Expression
        double result = (f * b) + (i / c) - (d * s);
 
        // Printing the result obtained after
        // all the promotions are done
        System.out.println("result = " + result);
    }
}

result = 626.7784146484375

Conversión de tipo explícito en expresiones

Al evaluar expresiones, el resultado se actualiza automáticamente a un tipo de datos más grande del operando. Pero si almacenamos ese resultado en un tipo de datos más pequeño, genera un error de tiempo de compilación, por lo que debemos encasillar el resultado. 

Ejemplo:

// Java program to Illustrate Type Casting
// in Integer to Byte
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Declaring byte array
        byte b = 50;
 
        // Type casting int to byte
        b = (byte)(b * 2);
 
        // Display value in byte
        System.out.println(b);
    }
}

100

Nota: en el caso de operandos individuales, el resultado se convierte a int y luego se encasilla en consecuencia, como en el ejemplo anterior.

Este artículo es una contribución de Apoorva Singh. Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.