17  Casting e Promoção

Conversões de tipo podem ajudar ou atrapalhar. Vamos usar com critério.

DicaAbertura narrativa

Todo bom programador evolui mais rápido quando entende por que um tema importa antes de memorizar sintaxe. Neste capítulo, vamos conectar conceito, contexto e prática para transformar teoria em habilidade real. Em Java, conversões de tipo aparecem o tempo todo, mesmo quando você não percebe. Saber diferenciar uma conversão automática de um casting explícito evita bugs silenciosos e decisões precipitadas. Você também vai perceber que números não são todos iguais: cada tipo tem limites, precisão e comportamento próprio.

DicaMapa mental do capítulo

• Ideia central: o que este tema resolve em projetos Java.
• Linguagem técnica: quais termos você precisa dominar.
• Aplicação prática: como usar no código do dia a dia.
• Armadilhas comuns: erros frequentes de iniciantes.
• Critério de domínio: como saber se você aprendeu de verdade.

Ao longo das seções, pense sempre em duas perguntas: “estou preservando a informação?” e “essa conversão deixa o código mais claro?”. Essas perguntas funcionam como um filtro simples para tomar boas decisões técnicas.

17.1 Estudo de caso guiado

Imagine uma pequena plataforma acadêmica para cadastro de alunos, notas e turmas. A cada aula, evoluímos essa plataforma com um novo recurso. Neste capítulo, o foco é aplicar o tema para deixar o sistema mais claro, seguro e fácil de manter. Por exemplo, uma nota pode ser digitada como número inteiro, mas o cálculo da média exige precisão decimal. Nesse cenário, a promoção de tipos ajuda a evitar perda de casas decimais. Já em relatórios, às vezes precisamos mostrar apenas a parte inteira de um valor, e aí o casting explícito entra em cena com responsabilidade.

17.2 Exemplo comentado em Java

double preco = 99.90;
int inteiro = (int) preco;   // casting explícito
int qtd = 3;
double total = qtd;          // promoção implícita

No exemplo, qtd é promovido automaticamente para double quando necessário, sem risco de perda de informação. Em contraste, preco perde a parte decimal ao ser convertido para int, porque o casting descarta o que vem após a vírgula. Essa diferença resume a regra prática: promoção costuma ser segura; casting exige atenção e justificativa.

17.3 Regras tecnicas de promocao numerica

Em Java, existe uma ordem de promocao numerica que o compilador aplica durante expressoes aritmeticas. Entender essa ordem reduz erros de interpretacao e ajuda a prever o tipo final do resultado sem depender de tentativa e erro.

As regras mais importantes sao estas:

1. byte, short e char sao promovidos para int em operacoes aritmeticas.
2. Se houver long na expressao, o resultado parcial tende para long.
3. Se houver float, a expressao sobe para float (a menos que exista double).
4. Se houver double, a expressao final sera double.

Isso significa que, mesmo quando voce opera dois valores pequenos, o Java pode gerar um resultado em int antes de qualquer atribuicao.

byte a = 10;
byte b = 20;
int soma = a + b;           // byte + byte vira int

char letra = 'A';
int codigo = letra + 1;     // char tambem participa como valor numerico

Esse comportamento existe para manter consistencia interna da linguagem e evitar ambiguidades durante calculos.

17.4 Casting de estreitamento: onde mora o risco

Quando voce converte de um tipo maior para um menor, ocorre o chamado estreitamento (narrowing). Nesse caso, parte da informacao pode ser descartada. Esse descarte pode acontecer por truncamento de casas decimais ou por estouro de faixa numerica.

double media = 8.75;
int mediaInteira = (int) media;   // 8, parte decimal descartada

int valorGrande = 130;
byte valorPequeno = (byte) valorGrande; // overflow: 130 nao cabe em byte

No segundo caso, o resultado nao gera excecao automaticamente. O programa continua rodando, mas com valor diferente do esperado. Por isso, castings de estreitamento devem ser acompanhados de validacoes de faixa.

int idade = 130;
if (idade >= Byte.MIN_VALUE && idade <= Byte.MAX_VALUE) {
    byte idadeCompacta = (byte) idade;
    System.out.println(idadeCompacta);
} else {
    System.out.println("Valor fora da faixa de byte");
}

17.5 Divisao inteira x divisao decimal

Uma armadilha recorrente em exercicios de media e percentual e esquecer que int / int resulta em divisao inteira. Nesse caso, a parte fracionaria e perdida antes mesmo da atribuicao.

int acertos = 7;
int total = 10;
double taxaErrada = acertos / total;         // resultado parcial: 0
double taxaCorreta = (double) acertos / total; // resultado: 0.7

Repare que o casting no operando muda o tipo da expressao inteira. Esse detalhe simples altera completamente o resultado final.

17.6 Literais numericos e sufixos

Outro ponto tecnico importante e o tipo padrao dos literais. Em Java:

• Literais inteiros sao int por padrao.
• Literais decimais sao double por padrao.
• Use L para indicar long.
• Use F para indicar float.

long populacao = 2147483648L;   // sem L, estoura o limite de int
float desconto = 0.15F;         // sem F, literal decimal seria double
double precisaoAlta = 0.15;     // double por padrao

Dominar sufixos evita erros de compilacao e melhora a legibilidade da intencao numerica no codigo.

17.7 Conversoes em contexto real de projeto

Em sistemas reais, castings aparecem em leitura de dados, calculo de indicadores, serializacao e integracao com APIs externas. Nesses cenarios, a decisao de converter tipos deve considerar tres criterios: seguranca da informacao, clareza da regra e impacto no comportamento do negocio.

Uma estrategia pratica e centralizar conversoes criticas em metodos com nomes claros, como calcularMediaComPrecisao ou converterNotaParaInteiro, em vez de espalhar castings por varias partes do codigo. Isso facilita manutencao, revisao e testes.

Tambem vale registrar no comentario de regra de negocio quando uma perda de precisao e intencional. Esse registro reduz interpretacoes erradas por quem for manter o sistema depois.

17.8 Erros clássicos e como evitar

1. Copiar código sem entender a intenção de cada linha.
2. Ignorar nomes claros para classes, métodos e variáveis.
3. Pular testes curtos após cada pequena alteração.
4. Tentar otimizar antes de ter uma versão correta.

Outro erro comum é converter tipos apenas para “fazer o código compilar”, sem avaliar impacto no resultado. Quando houver dúvida, imprima valores intermediários e compare o antes e depois da conversão. Também vale preferir nomes que revelem intenção, como mediaFinal ou valorArredondado, para deixar claro por que a conversão foi feita.

17.9 Checklist de domínio

• Consigo explicar o conceito com minhas palavras.
• Consigo implementar sem consultar o slide original.
• Consigo adaptar para um problema diferente.
• Consigo identificar e corrigir erros comuns.

Se você marca os quatro itens com segurança, já está em um bom nível para aplicar esse conteúdo em exercícios e projetos maiores. Se algum item ainda gera dúvida, revise apenas a parte específica e pratique com exemplos pequenos.

17.10 Trilha de prática (20-30 min)

1. Reescreva o exemplo em um arquivo novo.
2. Altere duas regras do problema e ajuste o código.
3. Adicione uma validação extra.
4. Execute e registre o resultado esperado.

Uma boa prática é testar casos-limite, como valores muito altos, negativos e decimais com muitas casas. Isso torna os efeitos do casting e da promoção mais visíveis. Ao final, escreva em uma frase por que cada conversão foi usada. Esse hábito acelera muito a fixação do conteúdo.

17.11 Fechamento

Ao finalizar este capítulo, você não deve apenas reconhecer a sintaxe: deve conseguir tomar decisões melhores de implementação. Esse é o passo que diferencia leitura passiva de aprendizado de verdade. Com o tempo, esse cuidado com tipos se transforma em reflexo técnico e melhora a qualidade de todo o seu código Java.

NotaExpansão didática complementar

Neste capitulo, o estudo de casting e promocao de tipos se torna realmente valioso quando voce deixa de enxergar o conteudo como uma lista de regras isoladas e passa a observar como cada decisao tecnica influencia a qualidade do programa, a facilidade de manutencao e a capacidade de adaptar a solucao sem quebrar o que ja estava funcionando, especialmente em atividades progressivas que simulam situacoes de projeto real.

Para consolidar o aprendizado com profundidade, vale estruturar sua pratica em uma sequencia objetiva na qual voce revisa o conceito principal, implementa um exemplo pequeno e legivel e, logo em seguida, analisa de maneira critica se houve melhoria concreta em conversoes seguras, perda de precisao e prevencao de bugs numericos, porque esse ciclo consciente transforma estudo passivo em desenvolvimento de criterio tecnico.

Quando esse processo se repete ao longo das semanas, voce comeca a perceber que sua evolucao nao depende de decorar respostas prontas, mas sim de interpretar problemas com mais maturidade, justificar escolhas com argumentos claros e construir solucoes cada vez mais consistentes, o que representa exatamente a transicao de iniciante para praticante autonomo dentro da trilha de Java.