Introdução à conversão de tipo em Java
Uma vez que variáveis e constantes de vários tipos serão reunidas em uma expressão, elas poderão ser alteradas para um tipo semelhante. Essa técnica de transformação de um único tipo predefinido em outro é conhecida como conversão de tipo em Java.
Conversão de tipo
Existem 2 tipos diferentes de conversão que estamos usando nas linguagens de programação.
1. Conversão implícita de tipos
Se a conversão de tipos for realizada instantaneamente por meio do compilador, sem o envolvimento do programador, a conversão de tipos será conhecida como conversão implícita de tipos. O compilador incentiva fundamentalmente todos os operandos para o tipo de dados do maior operando. Nenhuma perda de dados ocorre durante a conversão de dados. Nenhuma chance de gerar exceção através da conversão e, portanto, é conhecida como segurança de tipo. A conversão de uma quantidade de tamanho menor e um número muito maior pode ser uma conversão implícita. Transformação de dados do tipo inteiro para flutuar.
float i=0;
int j=10;
i=j;
// Isso pode ser uma transformação implícita, pois o float pode ser maior que um número inteiro, portanto, não há falta de dados E também nenhuma exceção.
2. Conversão explícita de tipos
A conversão de tipo que pode ser aplicada pelo programador é conhecida como conversão de tipo explícita. fundamentalmente, o programador faz uma expressão para se tornar de um tipo específico. A transformação explícita de tipos pode ser conhecida como conversão de tipo. A perda de dados pode ou não ocorrer durante a conversão de dados. Portanto, existe uma probabilidade de perda de detalhes. poderia gerar um erro se, talvez, tentasse executar sem a conversão de tipo. A transformação de um número maior em números menores pode ser uma conversão explícita.
float k=123.456
int i= (int) k
// pode ser uma conversão explícita e também (int) é um tipo de conversão, operador. Neste ponto, podemos conseguir escapar de uma exceção, mas você pode encontrar a perda visível de dados. ie i = 123
// .456 pode ser descartado no processo de conversão
Conversão de tipo em Java
Como outras linguagens de programação, existem 2 tipos de conversão em java:
Conversão implícita de tipo
- Geralmente, é o que chamamos de conversão de ampliação, e isso pode ser feito automaticamente porque estamos migrando para tipos de dados mais amplos. Portanto, se temos um número inteiro de 32 bits e queremos passar para um número inteiro de 64 bits, isso é mais amplo. Portanto, o valor pode ser movido com segurança para que isso possa ser feito implicitamente. E o compilador precisa tomar uma decisão sobre como fazer essas conversões, e as regras são bem diretas.
- Se tivermos uma expressão com vários tamanhos inteiros (Mistos), se tivermos um curto e um longo, qualquer que seja o maior tamanho inteiro, para o que as coisas o converterão. Portanto, se fizermos uma operação com um curto e um longo, o curto será implicitamente lançado junto.
- Se executarmos uma operação com tamanhos de ponto flutuante misturados, para termos um float e um double, eles sempre irão para o double porque double é o maior tamanho de ponto flutuante.
- E, se tivermos uma operação que use tipos inteiros mistos e tipos de ponto flutuante, o compilador será convertido para o maior ponto flutuante da equação. Portanto, se fizermos uma operação com long e à tona, o long será lançado para a tona.
- Se fizermos uma operação com long e double, o long será convertido em double.
Conversão explícita de tipos
- Executamos explicitamente em nosso código ao usar esta operação de conversão. Quando fazemos isso, assumimos a responsabilidade pelo que acontecer como resultado desse tipo de conversão. Por isso, podemos realizar conversões ampliadas e estreitas. Então, ampliando, passando de 32 bits para dizer 64 bits, diminuindo, passando de 64 bits para 32 bits. Devemos apenas estar cientes de que sabemos o que pode acontecer potencialmente.
- Se fizermos uma conversão explícita de um ponto flutuante para um número inteiro, para que os pontos flutuantes possam ter uma parte fracionária, o número inteiro não pode, portanto, qualquer parte fracionária seria descartada quando lançássemos a flutuação em um número inteiro.
- Você deseja ter cuidado ao executar uma conversão restritiva. Se tivermos um número inteiro de 64 bits, ele poderá armazenar valores muito grandes para caber em um número inteiro de 32 bits.
- Portanto, se convertermos esse de 64 bits para um de 32 bits, o programa realmente o fará, mas se o valor for muito grande para caber em um de 32 bits, você obterá alguns resultados estranhos. Então, você quer ter certeza de que, ao transmiti-lo, faça um elenco estreito que saiba que o que está fazendo é seguro.
- E o último é que você deseja ter cuidado ao converter de um número inteiro para um ponto flutuante, porque se você tiver um número inteiro com um grande número de dígitos significativos, devido à maneira como o ponto flutuante é armazenado, poderá perder alguns dos esses dígitos significativos.
Exemplos de conversão de tipo
Exemplos de conversão de tipo mencionados abaixo em detalhes:
Código:
Temos um programa simples aqui, alguma declaração na parte superior, float, double, byte, short e long, e as variáveis são nomeadas para ajudar a identificar como são seus tipos float é floatVal,
Código:
long is longVal
Código:
E o programa apenas imprime uma mensagem de Sucesso, se for executado.
Então, vamos ver como parte da conversão de tipos entra em ação aqui. Então vamos primeiro, vamos em frente e criar uma variável. Temos curto e vamos chamá-lo de resultado.
De fato, vamos em frente e chamemos de resultado1. E vamos apenas fazer uma tarefa simples. E então primeiro atribuiremos o byteVal a ele. Agora, como esperamos, se formos adiante e executarmos isso, execute-o com êxito.
Código:
Resultado:
Sabemos que é uma atribuição válida porque um byte pode ser atribuído a um curto porque é uma conversão cada vez maior.
Se pegarmos esse byteVal e o fizermos um longVal, então agora é realmente um longo, se executarmos isso, receberemos uma mensagem de erro aqui dizendo tipo incompatível, possível perda de conversão de longa para curta.
Código:
Então, o que podemos fazer aqui é fazer um elenco explícito. Vamos apenas colocar curto na frente disso. Então agora é válido para que possamos executá-lo.
Código:
E, claro, funciona. Porque o longo não podia ser curto, porque essa era uma conversão mais restritiva.
Resultado:
Mas, colocando o elenco explícito na frente dele, agora é válido. Se quisermos, podemos colocar uma notação de conversão muito explícita e dizer que você sabe, embora uma conversão de bytes seja legal, queremos mostrar explicitamente que a estamos convertendo colocando a transmissão curta lá, podemos fazer isso, e isso é completamente legal.
Código:
Resultado:
Então agora vamos dar uma olhada em outro cenário. Vamos criar outra variável que chamaremos de resultado2 , e resultado2 também é curto. E o que queremos fazer aqui é pegar nosso byteVal e subtrair o longVal. Agora sabemos que isso não é legal porque o resultado da expressão será o tamanho do maior número inteiro, que é o comprimento.
Código:
Portanto, se executarmos isso, obteremos um erro dizendo que não é válido converter um comprimento para um curto.
Mas digamos que queremos seguir em frente e manter esse resultado em um curto prazo. Precisamos fazer um elenco. Mas queremos lançar esse tempo é o valor de todo o resultado aqui. Então, o que vamos fazer é colocar o elenco curto na frente aqui.
Coloque o elenco curto na frente dele aqui. E envolva tudo entre parênteses. E corra.
Código:
Ele será executado com sucesso.
Resultado:
Agora declare outra variável chamada result3, mas declare essa como um longo. Então, obtivemos o resultado 3, e o que faremos aqui é atribuirmos o nosso longVal - floatVal. Portanto, executamos isso, o erro perde a conversão convertendo de float para long porque, sempre que tivermos um tipo inteiro e qualquer tipo de ponto flutuante, o resultado será o tipo de ponto flutuante.
Código:
Então, vamos em frente e converter nosso resultado agora em um float. Então, fazendo disso um float, poderemos seguir em frente e executá-lo. E corra com sucesso.
Código:
Resultado:
Mas agora, se pegarmos o floatVal aqui e o convertermos em doubleVal e se tentarmos executá-lo, obteremos o erro porque diz que o resultado será um double porque quando você faz um número inteiro e um ponto flutuante, é o tamanho do maior ponto flutuante da equação.
Código:
Então, vamos em frente e fazer esse resultado dobrar, agora podemos executá-lo.
Código:
Resultado:
Conclusão
1. Variáveis são fortemente tipadas em Java
2. Tipos primitivos
- Tipos de números inteiros, tipos de ponto flutuante, tipo char, tipo booleano
3. Conversão de tipo
- Muitas vezes, precisamos alternar entre tipos diferentes, pois nossos programas, à medida que aumentam a complexidade, provavelmente envolverão vários tipos de dados.
- O compilador pode lidar com conversões de tipo que estão aumentando, passando de um tipo para outro que pode conter valores maiores,
- Mas você também pode usar a conversão para executar explicitamente os tipos de conversões que o compilador não pode executar automaticamente.
Artigos recomendados
Este é um guia para a Conversão de tipos em Java. Aqui discutimos a introdução, digite a conversão em java, como implícita e explícita, juntamente com os exemplos usando diferentes situações. Você também pode consultar os seguintes artigos para saber mais:
- Construtor em Java
- Classificação em Java
- Construtor em Java
- JCheckBox em Java
- Jogue vs Joga | As 5 principais diferenças que você deve saber
- Como implementar a caixa de seleção no Bootstrap
- Conversão em Java com exemplos