Introducción a la conversión de tipos en Java
Una vez que las variables y las constantes de varios tipos se unirán dentro de una expresión, se pueden cambiar a un tipo similar. Esta técnica de transformar un solo tipo predefinido en otro se conoce como conversión de tipo en Java.
Conversión de tipo
Hay 2 tipos diferentes de conversión que estamos usando en lenguajes de programación.
1. Conversión de tipo implícito
Si la conversión de tipo se realiza instantáneamente a través del compilador sin la participación del programador, la conversión de tipo se conoce como conversión de tipo implícita. El compilador fomenta fundamentalmente cada operando hacia el tipo de datos del operando más grande. No se produce pérdida de datos durante la conversión de datos. No hay posibilidad de lanzar excepciones a través de la conversión y, por lo tanto, se conoce como type-safe. La conversión de una cantidad más pequeña puede ser una conversión implícita. Transformación de datos de tipo entero a flotante.
float i=0;
int j=10;
i=j;
// Esto puede ser una transformación implícita ya que flotante puede ser más grande que un número entero, por lo tanto, no falta información y tampoco hay excepción.
2. Conversión explícita de tipos
La conversión de tipo que se puede aplicar a través del programador se conoce como conversión de tipo explícita. fundamentalmente, el programador hace una expresión para convertirse en un tipo particular. La transformación explícita de tipos puede conocerse como conversión de texto. La pérdida de datos puede o no ocurrir durante la conversión de datos. Por lo tanto, existe una probabilidad de pérdida de detalles. podría arrojar un error si tal vez intentara realizar sin conversión de texto. La transformación de un número mayor a números de menor tamaño puede ser una conversión explícita.
float k=123.456
int i= (int) k
// esto puede ser una conversión explícita así como, (int) es typecast, operator. En este punto, podríamos lograr escapar de una excepción, pero puede encontrar la pérdida visible de datos. es decir, i = 123
// .456 se puede descartar en el proceso de conversión
Conversión de tipos en Java
Al igual que otros lenguajes de programación, hay 2 tipos de conversión en java:
Conversión de tipo implícito
- En general, esto es lo que llamamos conversión de ampliación, y esto se puede hacer automáticamente porque nos estamos moviendo a un tipo de datos más amplio. Entonces, si tenemos un número entero de 32 bits y queremos pasar a un número entero de 64 bits, es más amplio. Por lo tanto, el valor se puede mover de forma segura para que se puedan hacer implícitamente. Y el compilador tiene que tomar una decisión sobre cómo hacer estas conversiones, y las reglas son bastante sencillas.
- Si tenemos una expresión con múltiples tamaños enteros (mixtos), si tenemos cortos y largos, cualquiera sea el tamaño entero más grande es a lo que las cosas lo convertirán. Entonces, si hacemos una operación con un corto y un largo, el corto se incluirá implícitamente.
- Si realizamos una operación con tamaños mixtos de punto flotante, por lo que tenemos un flotante y un doble, siempre irán al doble porque doble es el tamaño de punto flotante más grande.
- Y luego, si tenemos una operación que utiliza tipos enteros mixtos y tipos de punto flotante, el compilador convertirá al punto flotante más grande de la ecuación. Entonces, si hacemos una operación con un largo y a flote, el largo se lanzará a flote.
- Si hacemos una operación con un largo y un doble, el largo se convertirá en un doble.
Conversión explícita de tipos
- Realizamos explícitamente nuestro código cuando usamos esta operación de conversión. Cuando hacemos eso, nos hacemos responsables de lo que suceda como resultado de ese tipo de conversión. Por eso, podemos realizar tanto la conversión de ampliación como la estrecha. Entonces, el ensanchamiento va de 32 bits a 64 bits, se reduce, pasando de 64 bits a 32 bits. Solo debemos ser conscientes de que sabemos lo que podría suceder potencialmente.
- Si hacemos un lanzamiento explícito desde un punto flotante a un entero, de modo que los puntos flotantes pueden tener una porción fraccional, el entero no puede, por lo que cualquier porción fraccional se descartaría cuando lanzamos ese flotador a un entero.
- Desea tener cuidado al realizar una conversión de reducción. Si tenemos un número entero de 64 bits, tiene la capacidad de mantener valores que son demasiado grandes para caber en un número entero de 32 bits.
- Entonces, si convertimos esos 64 bits en 32 bits, el programa realmente lo hará, pero si el valor es demasiado grande para caber en 32 bits, obtendrá algunos resultados extraños de eso. Por lo tanto, debe asegurarse de que cuando lo esté haciendo un lanzamiento estrecho sepa que lo que está haciendo es seguro.
- Y el último es que debe tener cuidado al convertir de un entero a un punto flotante porque si tiene un entero con una gran cantidad de dígitos significativos, debido a la forma en que se almacena el punto flotante, podría perder algo de Esos dígitos significativos.
Ejemplos de conversión de tipos
Ejemplos de conversión de tipos mencionados a continuación en detalle:
Código:
Tenemos un programa simple aquí, alguna declaración en la parte superior, float, double, byte, short y long, y cada una de las variables se nombra para ayudar a identificar cómo son sus tipos float es floatVal,
Código:
largo es largo
Código:
Y el programa simplemente imprime un mensaje de Éxito si se ejecuta.
Entonces, veamos cómo parte de la conversión de tipos entra en juego aquí. Entonces, antes que nada, sigamos adelante y creemos una variable. Tenemos cortos y simplemente lo llamaremos el resultado.
De hecho, sigamos adelante y llamémosle resultado1. Y hagamos una tarea simple. Y así, primero le asignaremos el byteVal. Ahora, como esperamos, si seguimos adelante y ejecutamos esto, entonces corre con éxito.
Código:
Salida:
Sabemos que es una asignación válida porque un byte puede asignarse en un corto porque es una conversión de ampliación.
Sin embargo, si tomamos este byteVal y lo convertimos en longVal, entonces ahora es realmente largo, si ejecutamos esto, recibimos un mensaje de error aquí que dice tipo incompatible, posible pérdida de conversión de largo a corto.
Código:
Entonces, lo que podemos hacer aquí es hacer un reparto explícito. Simplemente nos quedaremos cortos delante de esto. Entonces ahora es válido para que podamos ejecutarlo.
Código:
Y por supuesto, funciona. Porque el largo no pudo entrar en un corto porque esa fue una conversión cada vez más estrecha.
Salida:
Pero al poner el elenco explícito frente a él, ahora es válido. Si queremos, podemos poner una notación de lanzamiento muy explícita y decir que usted sabe, sabemos que aunque una conversión de bytes es legal, queremos mostrar explícitamente que la estamos lanzando al poner el lanzamiento corto allí, podemos hacer eso, y eso es completamente legal.
Código:
Salida:
Así que ahora echemos un vistazo a otro escenario. Vamos a crear otra variable que llamaremos result2 , y result2 también es corto. Y lo que queremos hacer aquí es tomar nuestro byteVal y queremos restar el longVal. Ahora sabemos que eso no es legal porque el resultado de la expresión será el tamaño del entero más grande, que es la longitud.
Código:
Entonces, si ejecutamos esto, recibimos un error que dice que no es válido convertir un largo a un corto.
Pero digamos que queremos seguir adelante y mantener ese resultado como breve. Necesitamos hacer un reparto. Pero queremos lanzar este momento es el valor del resultado completo aquí. Entonces, lo que vamos a hacer es poner el elenco corto aquí.
Pon el molde corto aquí delante. Y envuelva todo entre paréntesis. Y ejecútalo.
Código:
Se ejecutará con éxito.
Salida:
Ahora declare otra variable llamada result3, pero declare esta como larga. Entonces obtuve el resultado 3, y lo que haremos aquí es asignarle nuestro longVal - floatVal. Entonces ejecutamos eso, el error pierde la conversión al convertir de flotante a largo porque cada vez que tenemos un tipo entero y cualquier tipo de punto flotante, el resultado será el tipo de punto flotante.
Código:
Así que sigamos adelante y convierta nuestro resultado ahora en flotante. Entonces, al hacer que sea un flotador, deberíamos poder seguir adelante y ejecutarlo. Y corre con éxito.
Código:
Salida:
Pero ahora si tomamos el floatVal aquí y lo convertimos en un doubleVal y si tratamos de ejecutar esto, obtenemos el error porque dice que el resultado será un doble porque cuando haces un número entero y un punto flotante, es el tamaño del punto flotante más grande de la ecuación.
Código:
Así que sigamos adelante y hagamos que este resultado sea doble para que ahora podamos ejecutarlo.
Código:
Salida:
Conclusión
1. Las variables están fuertemente tipadas en Java
2. Tipos primitivos
- Tipos enteros, tipos de coma flotante, tipo char, tipo booleano
3. Conversión de tipo
- A menudo tenemos que movernos entre diferentes tipos porque a medida que nuestros programas, a medida que se vuelven más complejos, probablemente involucren múltiples tipos de datos.
- El compilador puede manejar conversiones de tipos que se están ampliando, moviéndose de un tipo a otro que puede contener valores más grandes,
- Pero también puede usar la conversión para realizar explícitamente esos tipos de conversiones que el compilador no puede realizar automáticamente.
Artículos recomendados
Esta es una guía para la conversión de tipos en Java. Aquí discutimos la introducción, la conversión de tipos en Java como implícita y explícita junto con los ejemplos que utilizan diferentes situaciones. También puede consultar los siguientes artículos para obtener más información.
- Constructor en Java
- Ordenar en Java
- Constructor en Java
- JCheckBox en Java
- Lanzamiento vs Lanzamientos | Las 5 principales diferencias que debes saber
- Cómo implementar la casilla de verificación en Bootstrap
- Conversión en Java con ejemplos