0Pricing
Java Academy · Aula

Conversões de Alargamento e Redução

Aprenda as conversões automáticas de alargamento e como realizar conversões explícitas de redução com segurança.

Conversões de Alargamento e Redução é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Conversões de tipos em Java

Java permite converter valores entre tipos compatíveis. Há duas direções:

  • Ampliação — conversão para um tipo maior (segura, automática)
  • Redução — conversão para um tipo menor (arriscada, exige uma conversão explícita)

Conversão por ampliação

A ampliação ocorre automaticamente quando você atribui um valor a um tipo compatível maior. Nenhum dado é perdido porque o tipo de destino pode representar todos os valores da origem.

Ordem de ampliação: byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

Conversão por redução

A redução precisa ser feita explicitamente com um operador de conversão (type). O valor pode ser truncado ou corrompido se não couber no tipo de destino.

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

Estouro durante a redução

Quando um valor sofre estouro durante a redução, Java o faz retornar ao início usando aritmética modular — nenhuma exceção é lançada. Você precisa se proteger disso manualmente.

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

Conversões de caractere e int

char é um inteiro sem sinal de 16 bits que representa um ponto de código Unicode. Ele é ampliado automaticamente para int, mas precisa ser convertido explicitamente de int de volta para char.

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

Truncamento de ponto flutuante para inteiro

Converter um número de ponto flutuante para um inteiro trunca em direção a zero — não arredonda. Use Math.round() se precisar arredondar.

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

Conversões de String para números

A análise de uma String para obter um número usa métodos de classes envoltórias, não uma conversão de tipo. Passar uma string não numérica lança NumberFormatException.

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

Conversões de números para String

É possível converter um número em uma String usando String.valueOf(), Integer.toString() ou a concatenação de strings com "".

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

Promoção em expressões

Em expressões aritméticas, o Java promove automaticamente os operandos:

  • byte, short, char → promovidos para int antes da operação
  • Se um dos operandos for long, o resultado será long
  • Se um deles for float ou double, o resultado corresponderá ao tipo mais abrangente
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

Operadores de atribuição composta

Operadores compostos como +=, -= e *= incluem uma conversão implícita para um tipo menor. Isso permite escrever código conciso com variáveis byte e short.

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

Prática: análise segura de inteiros

Um padrão comum em aplicações reais: analisar a entrada do usuário com segurança, validar o intervalo e reduzir o resultado exatamente ao tipo necessário.

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

Verificação rápida

Qual é a saída do código a seguir?

double d = -7.8;
int i = (int) d;
System.out.println(i);

Recapitulação: ampliação e redução de tipo

Principais conclusões:

  • A ampliação é automática e segura, seguindo a sequência dos tipos inteiros, do menor ao maior, até double
  • A redução exige uma conversão explícita e pode causar perda de dados ou estouro
  • O tipo de caractere é ampliado para um tipo inteiro; um tipo inteiro pode ser reduzido novamente para um caractere com uma conversão
  • A conversão de ponto flutuante para inteiro trunca em direção a zero, em vez de arredondar
  • Use Integer.parseInt/Double.parseDouble para converter Strings em números
  • Os operadores compostos (+=, *=) incluem conversões implícitas para tipos menores

Perguntas Frequentes

A aula “Conversões de Alargamento e Redução” é grátis?

Sim — o texto completo de “Conversões de Alargamento e Redução” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Conversões de Alargamento e Redução”?

Aprenda as conversões automáticas de alargamento e como realizar conversões explícitas de redução com segurança. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Conversões de Alargamento e Redução”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tipos Primitivos versus Tipos de Referência
  2. Conversões de Alargamento e Redução
  3. O Operador instanceof
  4. Conversão de Tipos na Prática
← Voltar para Java Academy