1. Conversão implícita (automática) de tipos
Em Java (assim como em outras linguagens) as variáveis têm tipo estrito — se uma variável for declarada como int, ela só pode armazenar números inteiros, e se for double — apenas números de ponto flutuante. Mas, em programas reais, muitas vezes surge a situação em que é preciso “transferir” um valor de uma variável para outra de tipo diferente. Por exemplo:
- Recebemos de um método um int, mas queremos usá-lo como double para cálculos com frações.
- Armazenamos o código de um caractere como número (int), mas queremos obter o próprio caractere (char).
- Temos um resultado de cálculos em double, mas precisamos de um resultado inteiro (int), por exemplo, para exibir a quantidade de maçãs inteiras.
Em Java há duas maneiras principais de conversão de tipos: implícita (automática) e explícita (manual).
O que é isso?
Conversão implícita é quando o Java, “sem sua intervenção”, converte um valor de um tipo para outro, se isso for seguro e não levar à perda de dados.
Isso acontece quando você atribui um valor de um tipo menor a uma variável de um tipo maior. Por exemplo, de int para double, de char para int, de float para double.
Analogia: imagine que você tem um copo d’água (int) e um balde (double). Se você despejar a água do copo no balde — nada vai entornar, tudo vai caber. O Java, nesses casos, permite a conversão automática.
Exemplo: int → double
int apples = 5;
double applesWeight = apples; // int vira double automaticamente
System.out.println(applesWeight); // 5.0
Exemplo: char → int
Cada caractere em Java é apenas um número da tabela Unicode. Portanto, a conversão de char para int ocorre automaticamente:
char letter = 'A';
int code = letter; // 'A' se transforma em 65 (código do caractere no Unicode)
System.out.println(code); // 65
Tabela de conversões implícitas
| De | Para (implícito) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
Importante: A conversão implícita funciona apenas no sentido de “ampliação” (do menor para o maior).
2. Conversão explícita (manual) de tipos (type casting)
A conversão explícita é necessária quando você quer converter um valor de um tipo maior para um menor ou entre tipos incompatíveis. Nesse caso, o Java exige que você indique explicitamente que está ciente da possível perda de dados.
Analogia: você tenta despejar água de um balde (double) em um copo (int) — parte da água pode derramar, e o Java exige que você diga: “Sim, eu entendo que parte dos dados pode se perder!”
Sintaxe
tip_naznacheniya peremennaya = (tip_naznacheniya) vyrazhenie;
Exemplo: double → int
double price = 12.99;
int roundedPrice = (int) price; // a parte fracionária é simplesmente descartada!
System.out.println(roundedPrice); // 12
Atenção: Não há arredondamento! Simplesmente “cortamos” tudo após o ponto. Para arredondamento, use Math.round().
Exemplo: int → char
int code = 66;
char letter = (char) code; // 66 — é o caractere 'B'
System.out.println(letter); // B
Exemplo: double → float
double d = 3.1415926535;
float f = (float) d; // parte da precisão se perde
System.out.println(f); // 3.1415927 (menos casas decimais)
3. Conversão entre números e caracteres (char e números)
Por que isso é possível?
Em Java, caracteres (char) na verdade são apenas números da tabela Unicode. Por isso, podem ser livremente convertidos para int e vice-versa.
Exemplo: char → int
char ch = '\u0416';
int code = ch;
System.out.println(code); // 1046
Exemplo: int → char
int code = 8364;
char symbol = (char) code;
System.out.println(symbol); // €
Prática: imprimindo o alfabeto
for (int i = 65; i < 65 + 26; i++) {
System.out.print((char) i + " ");
}
// Saída: A B C D ... Z
4. Conversão entre inteiros e números de ponto flutuante
int → double (implícita)
int count = 10;
double avg = count; // ampliação implícita
System.out.println(avg); // 10.0
double → int (explícita)
double score = 8.75;
int rounded = (int) score;
System.out.println(rounded); // 8
Como arredondar segundo as regras da matemática?
Se for preciso não apenas “descartar” a parte fracionária, mas arredondar para o inteiro mais próximo, use Math.round():
double price = 8.75;
int rounded = (int) Math.round(price);
System.out.println(rounded); // 9
5. O que acontece ao “estreitar” o tipo? Perda de dados
Exemplo: int → byte
int big = 300;
byte small = (byte) big;
System.out.println(small); // 44 (!)
Por que 44? Porque byte armazena valores de -128 a 127, e se o número não couber — ocorre um “corte” pelo módulo 256 (resto da divisão).
Exemplo: double → int
double d = 1e20;
int i = (int) d;
System.out.println(i); // -2147483648 (valor mínimo de int)
O número é grande demais para caber no intervalo de int, e o resultado se torna “estranho”.
6. Conversão em cálculos: tipos “mistos”
Exemplo: int + double
int a = 3;
double b = 2.5;
double result = a + b; // int se tornará double automaticamente
System.out.println(result); // 5.5
Exemplo: char + int
char ch = 'A'; // 65
int offset = 2;
char next = (char) (ch + offset); // char se tornará int automaticamente
System.out.println(next); // C
7. Conversão entre números e strings
Embora isso não seja exatamente “conversão de tipos”, muitas vezes é necessário converter um número em string e vice-versa.
int → String
int x = 123;
String s = Integer.toString(x);
// ou simplesmente: String s = "" + x;
String → int
String s = "456";
int x = Integer.parseInt(s);
8. Erros típicos e nuances
Erro nº 1: Perda da parte fracionária ao converter de double → int. Muito frequentemente iniciantes pensam que (int) 3.99 dará 4. Na verdade, o resultado é 3, a parte fracionária é simplesmente descartada. Para arredondamento correto, use Math.round().
Erro nº 2: O “estreitamento” implícito não funciona. Não é possível simplesmente escrever int x = 300; byte b = x; — o compilador emitirá um erro. É preciso indicar explicitamente (byte) x, mas esteja preparado para resultados estranhos se o número for maior que o intervalo de byte.
Erro nº 3: Conversão entre tipos incompatíveis. Não é possível escrever (int) "123" — para converter uma string em número, use Integer.parseInt().
Erro nº 4: Problemas com char e int. A conversão de int para char funciona apenas para valores que realmente existem no Unicode. Se você passar um número muito grande, o resultado será um caractere inesperado.
Erro nº 5: Tipos mistos em expressões. Se uma expressão contiver int e double, o resultado será sempre double. Isso pode afetar inesperadamente a lógica do programa se você espera um número inteiro.
Erro nº 6: Arredondar não é converter tipo! (int) x — não é arredondamento, e sim apenas o descarte da parte fracionária. Para arredondamento, use Math.round().
GO TO FULL VERSION