Conversão de tipos em Java: ampliação, redução e conversões

O que significa conversão de tipos

Java é de tipagem estática: todo valor tem um tipo, e o compilador não deixa você misturar tipos incompatíveis silenciosamente. A conversão de tipos é a forma de converter um valor de um tipo para outro — às vezes o Java faz isso por você, e às vezes você precisa solicitar explicitamente.

Há duas direções. Ir de um tipo menor para um maior (um int para um double) é seguro e acontece automaticamente. Ir de um tipo maior para um menor (um double para um int) pode perder dados, então o Java obriga você a deixar isso explícito com uma conversão.

Ampliação: a conversão automática

Uma conversão de ampliação move um valor para um tipo com mais espaço. Nada pode ser perdido, então o Java faz isso por você sem uma conversão:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automático

        System.out.println(price);   // 7.0
    }
}

O int 7 se encaixa em um double e se torna 7.0. A ordem de ampliação para números é byte -> short -> int -> long -> float -> double; atribuir da esquerda para a direita ao longo dessa cadeia nunca precisa de conversão. É por isso que misturar tipos em operações aritméticas geralmente "simplesmente funciona" — o Java amplia primeiro o operando menor.

Redução: a conversão explícita

No outro sentido — uma conversão de redução — pode haver perda de dados, então o compilador recusa a menos que você coloque o tipo de destino entre parênteses na frente do valor:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // conversão de redução explícita

        System.out.println(whole);   // 3, não 4
    }
}

(int) pi é a conversão. Repare no que ela faz: trunca em direção a zero, simplesmente descartando a parte decimal. 3.9 se torna 3, e -3.9 se torna -3. Ela não arredonda. Se você quer arredondar, essa é uma ferramenta diferente:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (trunca)
        System.out.println(Math.round(value));    // 4  (arredonda)
    }
}

Esquecer que uma conversão trunca é um dos erros mais comuns entre iniciantes — se o seu número "arredondado" sai sempre um a menos, geralmente é por isso.

A armadilha da divisão inteira

Essa pegadinha pega todo mundo uma vez. Quando ambos os operandos são int, o operador / faz divisão inteira e descarta o resto — antes de qualquer atribuição a um double:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - a divisão é feita primeiro como ints!
        double right = (double) a / b; // 3.5  - converta um operando primeiro

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b é 7 / 2, calculado inteiramente com aritmética de int, o que dá 3. Ampliar para double depois apenas transforma 3 em 3.0 — o .5 já se foi. Converter um operando para double primeiro ((double) a / b) força toda a expressão para ponto flutuante, resultando no 3.5 que você queria. Você só precisa converter um lado; o Java amplia o outro para combinar.

Quando a redução estoura

Uma conversão não verifica se o valor cabe. Se não couber, os bits são simplesmente cortados e você obtém um resultado surpreendente — sem erro, sem aviso:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte só comporta -128..127

        System.out.println(small);   // 44, não 300
    }
}

300 não cabe em um byte, então os bits altos são descartados e você obtém 44. Essa é uma perda de dados "silenciosa" — o programa roda bem e dá uma resposta errada. Só reduza quando tiver certeza de que o valor cabe no tipo menor.

Convertendo entre números e strings

Uma String é um objeto, não um número, então você não pode convertê-la com (int) — isso é um erro de compilação. A conversão usa métodos dedicados:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Para ir de texto para número, use Integer.parseInt / Double.parseDouble. Se a string não for um número válido (digamos "hello"), esses métodos lançam uma NumberFormatException. Para ir de um número para texto, use String.valueOf(n) ou simplesmente concatene com "" — porque n + "" força o int a virar uma String. Atenção à diferença entre "5" + 1 (que dá a string "51") e 5 + 1 (que dá 6); o + significa concatenação no momento em que uma String está envolvida.

Convertendo objetos

A conversão também se aplica a referências de objetos, não apenas a primitivos. Você pode converter uma referência para um tipo relacionado ao longo de uma cadeia de herança — ampliar para um tipo pai é automático, reduzir de volta exige uma conversão explícita e só é seguro se o objeto realmente for daquele tipo:

Object o = "hello";
String s = (String) o;        // OK: o realmente aponta para uma String
Integer bad = (Integer) o;    // compila, mas lança ClassCastException em tempo de execução

A segunda conversão compila, mas explode em tempo de execução com uma ClassCastException porque o objeto é uma String, não um Integer. Você verá isso direito quando chegar à herança e ao polimorfismo; por enquanto, basta saber que a sintaxe (Type) é a mesma ideia aplicada a objetos.

Próximo: if-else

A conversão permite remodelar valores; o próximo passo é fazer seu programa escolher entre caminhos com base nesses valores. A instrução if-else executa um bloco quando uma condição é verdadeira e outro quando é falsa — a base de toda decisão que seu código toma. Essa é a próxima página.