Conversão de Tipos em Java

Conversão de tipo é transformar um valor de um tipo em outro. Em Java, isso ocorre de duas formas: conversões de alargamento (widening), que acontecem automaticamente e nunca perdem informação, e conversões de estreitamento (narrowing), que exigem um cast explícito e podem perder dados.

Conversão de alargamento (implícita)

Uma conversão de alargamento move um valor para um tipo maior. O compilador faz isso automaticamente — sem necessidade de sintaxe especial:

int i = 100;
long l = i;        // int → long (widening)
double d = l;      // long → double (widening)

System.out.println(i);   // 100
System.out.println(l);   // 100
System.out.println(d);   // 100.0

A ordem padrão de alargamento é:

byte → short → int → long → float → double
              char ↗

(char se alarga para int e além, mas não para short ou byte.)

O alargamento nunca perde intervalo — um long sempre cabe no intervalo de um double, mesmo que o double não consiga representar todos os valores long com exatidão. Fique atento a essa lacuna de representação exata em valores extremos.

Cast de estreitamento (explícito)

Uma conversão de estreitamento move um valor para um tipo menor. Java se recusa a fazer isso implicitamente porque dados podem ser perdidos. Você deve indicar explicitamente com (targetType):

double d = 9.99;
int i = (int) d;   // explicit narrowing cast

System.out.println(i);   // 9 — the fractional part is dropped

O cast trunca em direção a zero — ele não arredonda.

Para inteiros, um cast mantém apenas os bits de ordem baixa:

int big = 130;
byte b = (byte) big;
System.out.println(b);   // -126 — overflow wraps around

byte tem 8 bits, intervalo de -128…127. Os bits de 130 (10000010) são interpretados como -126 em complemento de dois.

Um cast comum: divisão inteira para número real

Aritmética puramente inteira usa divisão inteira — 5 / 2 == 2, não 2.5. Para obter um resultado real, faça o cast de pelo menos um operando antes da divisão:

int total = 5;
int count = 2;

double avgWrong = total / count;          // 2.0 — division is still integer
double avgRight = (double) total / count; // 2.5 — total widened first

Essa é a razão mais comum para usar um cast.

Casts de referência

A sintaxe (Type) também funciona com objetos — embora seja uma verificação em tempo de execução, não uma conversão. Fazer o cast de uma referência é essencialmente dizer "confie em mim, este objeto é do tipo X":

Object o = "Hello";
String s = (String) o;            // OK at runtime
System.out.println(s.length());   // 5

Object n = Integer.valueOf(7);
String bad = (String) n;          // throws ClassCastException at runtime

Para fazer o cast de uma referência com segurança, verifique o tipo primeiro com instanceof:

Object o = "Hello";
if (o instanceof String) {
    String s = (String) o;        // guaranteed safe
    System.out.println(s.length());
}

Correspondência de padrão para instanceof (Java moderno) permite fazer a verificação e o cast em uma única etapa. Casts de referência são abordados adequadamente em POO e Polimorfismo.

Um exemplo funcional

Quando o compilador "ajuda" — e quando não

Um caso sutil a observar: aritmética com byte, short ou char é automaticamente promovida para int antes da operação. O resultado é um int:

byte a = 10;
byte b = 20;
// byte sum = a + b;       // compile error: result is int
byte sum = (byte) (a + b);  // explicit cast needed

Isso pega todo mundo na primeira vez. Ou armazene o resultado em int, ou faça o cast de volta.

Regras práticas

• Alargue livremente — nenhum cast necessário, sem perdas.
• Estreite com um cast e uma verificação — certifique-se de que o valor realmente cabe.
• Para divisão de números reais a partir de inteiros, faça o cast de um operando para double.
• Para cálculos monetários, não use double — use BigDecimal para evitar erros de arredondamento de ponto flutuante binário.

O que vem a seguir

Operadores Java — a visão geral completa de todos os operadores que a linguagem oferece.

Prática