Primeiros programas em Java

Um primeiro programa Java fornece ao computador uma pequena lista de instruções. A classe e o método main que as envolvem indicam a Java onde essas instruções pertencem e onde a execução começa.

Coloque instruções dentro de main

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

As chaves externas delimitam o corpo da classe. As chaves internas delimitam o corpo do método. Quando esse programa começa, Java executa a primeira instrução dentro de main. Outras instruções colocadas abaixo são executadas de cima para baixo. Quando main termina, esse pequeno programa é encerrado.

Copie public static void main(String[] args) com cuidado. Aqui, public permite que o inicializador chame o método, static permite que ele seja executado sem criar um objeto antes, e void indica que o método não retorna resultado. String[] args recebe palavras digitadas na linha de comando após o nome do programa. Você pode exibir uma mensagem sem usar essas palavras.

Faça a pontuação e os nomes corresponderem

Uma instrução como System.out.println("Hi"); termina com ponto e vírgula. Uma chave de abertura { precisa de uma chave de fechamento }. Os cabeçalhos de classe e método mostrados acima abrem blocos; não substitua essas chaves de abertura por pontos e vírgulas. Recuar a instrução quatro espaços a mais que o cabeçalho do método torna visível o aninhamento.

Salve public class Hello em Hello.java. O nome da classe pública e a parte anterior a .java devem corresponder exatamente, incluindo as maiúsculas. Se a declaração disser public class Other, o arquivo deverá ser Other.java. Uma mensagem do compilador que diz que a classe deveria ser declarada em outro arquivo aponta para essa divergência.

Java distingue maiúsculas de minúsculas. O nome System deve começar com S maiúsculo; system.out.println("Hi"); falha na compilação. Um método chamado Main é diferente de main. Uma classe que contém apenas Main pode compilar, mas o inicializador não encontra o método de entrada pretendido quando você a executa.

Torne o código legível

Use uma instrução por linha e quatro espaços de recuo para cada nível de chaves. A maioria dos espaços e das quebras de linha entre elementos do código não afeta a compilação. Espaços dentro de texto entre aspas afetam a saída. Por convenção, nomes de classes usam PascalCase, como em TravelTime.

Um comentário explica o código para as pessoas. Java ignora tudo o que vem depois de // naquela linha. Um comentário de bloco começa com /* e termina com */, e pode ocupar várias linhas. Um comentário útil explica uma razão, como // Convert hours to seconds, ao lado de uma conversão cuja finalidade possa não estar clara.

Reconheça a forma mais curta

O Java 25 e versões posteriores também oferecem suporte a um arquivo-fonte compacto:

void main() {
    IO.println("Hello, world!");
}

Essa forma omite a declaração explícita da classe. IO.println exibe uma linha, e IO.readln("Your name: ") exibe uma solicitação e retorna a linha digitada. A forma clássica com classe também funciona em versões anteriores de Java; ambas as formas fornecem um método main onde a execução começa.

Escrever código-fonte e executar um programa são etapas separadas. Java primeiro verifica e traduz seu código e depois o executa. Saber qual etapa falhou ajuda você a decidir onde procurar.

Compile o código-fonte e inicie a classe

Código-fonte é o texto em um arquivo .java. O compilador, javac, traduz código-fonte válido em bytecode em um arquivo .class. A Máquina Virtual Java (JVM) executa esse bytecode. Uma JVM adequada permite executar o mesmo bytecode em diferentes sistemas operacionais.

Abra um terminal na pasta que contém Hello.java e digite:

javac Hello.java
java Hello

O primeiro comando cria Hello.class quando a compilação é bem-sucedida. O segundo inicia o programa. Seu argumento é o nome da classe, sem .class: java Hello.class pede ao inicializador que encontre um nome de classe incorreto e falha.

O JDK, ou Kit de Desenvolvimento Java, fornece ambos os comandos. Uma IDE, como IntelliJ IDEA, Eclipse, NetBeans ou Visual Studio Code com suporte a Java, realiza a compilação e a inicialização quando você pressiona Run. Ela pode marcar erros enquanto você digita, mas esses continuam sendo erros da mesma linguagem Java.

Desde o Java 11, o modo de arquivo-fonte oferece um atalho para um único programa pequeno:

java Hello.java

Isso compila o código-fonte na memória e o executa sem deixar um arquivo .class. Mantenha as duas formas distintas: java Hello inicia uma classe compilada, enquanto java Hello.java inicia o código-fonte.

Leia erros de compilação

Um erro de compilação impede que a compilação seja concluída. Por exemplo, a falta de um ponto e vírgula pode produzir:

Hello.java:3: error: ';' expected
        System.out.println("Hello")
                                   ^

A mensagem identifica o arquivo, a linha e o local onde o compilador percebeu o problema. O erro real pode estar antes: uma aspa não fechada em uma linha pode confundir as linhas posteriores. Leia a linha marcada e a anterior. Corrija o primeiro erro informado e compile novamente antes de alterar várias outras linhas. Uma correção pode eliminar muitas mensagens posteriores.

Distinga erros de execução de respostas incorretas

Se uma variável inteira divisor contém zero, 5 / divisor falha durante a execução com ArithmeticException: / by zero. A instrução aritmética pode ser um código-fonte válido mesmo que seus valores em tempo de execução causem uma falha.

Um programa que exibe uma média de 8 quando o valor correto é cerca de 8,33 tem um erro de lógica. Nenhuma mensagem do compilador pode dizer que esse é o resultado incorreto para sua tarefa. Teste com entradas conhecidas, examine valores intermediários e encontre o primeiro cálculo incorreto.

Trabalhe em um ciclo curto: editar, salvar, compilar, executar, testar. Salvar é importante: a compilação lê o arquivo salvo, então alterações não salvas não podem mudar o programa compilado.

A saída exibida é a primeira maneira de ver o que um programa faz. Java permite controlar os caracteres exibidos e o ponto em que a próxima linha começa.

Acompanhe a posição da saída

System.out.print(...) escreve seu valor e deixa a posição de saída na mesma linha. System.out.println(...) escreve seu valor e depois inicia uma nova linha. Chamar System.out.println() com parênteses vazios acrescenta apenas uma quebra de linha.

System.out.print("Hello");
System.out.print(", ");
System.out.println("world");
System.out.println("Bye");

As duas primeiras chamadas deixam a posição depois do espaço que segue a vírgula. A terceira acrescenta world nessa posição e depois passa para uma nova linha. A saída exata é:

Hello, world
Bye

Java não insere espaços entre chamadas. Se você remover o espaço em ", ", a primeira linha se tornará “Hello,world”. Um println() vazio entre as duas últimas instruções criaria uma linha em branco entre as mensagens.

Decida se você quer texto ou um valor

Um literal de string é um texto entre aspas duplas. Exibir "7 * 6" mostra o texto “7 * 6”. Exibir 7 * 6 avalia a multiplicação e mostra “42”. As aspas são sinais de pontuação do código; elas não são exibidas como parte do literal.

Da mesma forma, se name armazena “Ada”, System.out.println(name); mostra “Ada”, enquanto System.out.println("name"); mostra “name”. Use a variável sem aspas quando quiser seu valor armazenado.

Aspas simples têm outra função. 'A' é um valor char. 'Hello' não pode conter uma mensagem com vários caracteres e causa um erro de compilação. Use "Hello" para esse texto.

Coloque caracteres especiais em uma cadeia de caracteres

Uma sequência de escape começa com uma barra invertida e representa um caractere dentro do literal.

Por exemplo:

System.out.println("She said \"hi\"");
System.out.println("C:\\Users");

Essas instruções exibem She said "hi" e C:\Users, em linhas separadas. As barras invertidas extras indicam a Java como interpretar o caractere seguinte; nem todas são copiadas para a saída.

Uma única chamada também pode exibir várias linhas:

System.out.println("Name:\tAda\nAge:\t36");

A tabulação separa o rótulo do valor, e \n coloca a idade na próxima linha. A chamada println também acrescenta sua própria quebra de linha final. Uma tabulação avança até uma parada de tabulação, então sua largura visível depende do ambiente de saída.

Um literal de string comum entre aspas deve abrir e fechar na mesma linha do código-fonte. Pressionar Enter no meio dele deixa um literal não fechado. Para dividir uma mensagem longa entre linhas do código-fonte, escreva dois literais completos unidos com + ou use chamadas de exibição separadas.

Uma variável dá um nome a um valor para que instruções posteriores possam usá-lo. Seu tipo informa a Java que tipo de valor ela pode conter; uma atribuição altera o valor armazenado.

Declare e inicialize

int age;
age = 36;

A declaração apresenta age como um int. A atribuição armazena 36. A forma combinada int age = 36; é chamada de inicialização. Uma variável local deve receber um valor antes de ser lida. Declarar int age; e imediatamente exibir age gera um erro informando que a variável pode não ter sido inicializada.

Declare um nome uma vez no mesmo corpo de método. Para alterar seu valor depois, escreva age = 37;, sem repetir int. Um segundo int age = 37; nesse corpo tenta declarar a mesma variável novamente.

Leia a atribuição da direita para a esquerda

O lado direito de = é calculado primeiro. Java então armazena esse resultado na variável à esquerda:

int count = 5;
count = count + 1;

A segunda instrução lê o valor atual 5, soma 1 e armazena 6. O sinal = indica atribuição, não uma afirmação matemática de que um número é igual a ele mesmo mais um. O lado esquerdo deve indicar um lugar para armazenar o valor; 36 = age; é inválido.

A atribuição copia o valor naquele momento:

int a = 5;
int b = a;
a = 10;

Agora a contém 10 e b contém 5. Não há um vínculo contínuo que recalcule b quando a muda.

Acompanhe uma troca

Suponha que first contenha 4 e second contenha 9. A sequência first = second; second = first; perde o 4 na primeira etapa e deixa ambos os valores em 9. Preserve primeiro o valor original:

int temp = first;
first = second;
second = temp;

Uma tabela de rastreamento registra cada variável após cada instrução. Para int x = 3; x = x * 2; x = x + 1;, os valores são 3, depois 6 e depois 7. Atualize uma linha por vez usando os valores armazenados mais recentes.

Escolha nomes úteis e tipos fixos

Nomes podem conter letras, algarismos, sublinhados e cifrões. Eles não podem começar com um algarismo nem ser uma palavra reservada como class. Maiúsculas e minúsculas importam: total e Total são diferentes. Use nomes descritivos em camelCase, como distanceKm ou secondsLeft.

Uma variável final só pode receber uma atribuição. final int SECONDS_PER_HOUR = 3600; dá um nome claro a um fator de conversão fixo. Uma nova atribuição a ela falha na compilação. Por convenção, constantes usam palavras em maiúsculas separadas por sublinhados.

Desde o Java 10, var pode inferir o tipo de uma variável local a partir de seu inicializador. var count = 10; infere int; var price = 2.5; infere double. O tipo inferido permanece fixo. var count; falha porque não há um inicializador a partir do qual inferir o tipo.

O tipo de um valor controla seu intervalo, a escrita de seu literal e os cálculos que Java pode fazer com ele. Use int para contagens comuns e double para medidas comuns, conhecendo também os outros tipos primitivos.

Compare os oito tipos primitivos

Valores finitos de float vão aproximadamente de −3,4 × 10³⁸ a +3,4 × 10³⁸; valores finitos de double vão aproximadamente de −1,8 × 10³⁰⁸ a +1,8 × 10³⁰⁸. Esses intervalos amplos não tornam todos os decimais dentro deles exatamente representáveis.

Um char frequentemente representa um único caractere, como 'A'. Alguns caracteres Unicode exigem duas unidades de código UTF-16, então um char não pode representar todos os caracteres possíveis. 'A' tem código numérico 65, 'a' tem 97 e '7' tem 55. O caractere '7' é diferente do inteiro 7. Um boolean não é um número: boolean active = 1; falha.

Escreva literais para seus tipos

Um literal escreve um valor diretamente no código-fonte. 42 é um literal int, 42L é um long, 3.5 é um double e 3.5f é um float. Literais de caractere usam aspas simples; literais de String usam aspas duplas. Nomes de tipos primitivos são escritos em minúsculas, enquanto String começa com letra maiúscula.

Escreva long large = 3000000000L;. Sem o L, esse literal inteiro é grande demais. Escreva float rate = 3.5f;: 3.5 sem sufixo tem tipo double, que Java não converte silenciosamente por estreitamento para float. Uma constante inteira que cabe no tipo pode inicializar um tipo inteiro menor: byte b = 100; compila, mas byte b = 200; não.

Sublinhados entre algarismos tornam um literal legível: 1_000_000 tem o mesmo valor que 1000000. A notação científica usa e, como em 1.5e3, que significa 1500,0. Decimais no código-fonte sempre usam ponto.

Observe o intervalo da operação

Um cálculo inteiro pode sofrer estouro sem mensagem de erro. Somar 1 ao maior int faz o resultado dar a volta até o menor int. O produto 50_000 * 50_000 usa aritmética int e produz -1794967296. Em 50_000L * 50_000, um operando é long, então o produto é o valor correto 2500000000.

Alterar apenas a variável de destino para long é tarde demais para corrigir um produto int que já sofreu estouro. Escolha um operando de tipo suficientemente amplo antes da multiplicação.

Valores em ponto flutuante têm outra limitação. Muitas frações decimais são armazenadas como aproximações binárias: 0.1 + 0.2 exibe 0.30000000000000004. Formate esses resultados para exibição. Cálculos monetários exatos podem armazenar centavos inteiros em um long; a classe BigDecimal é outra opção para decimais exatos.

Uma String contém texto, incluindo espaços, algarismos, pontuação ou nenhum caractere. O operador + pode combinar esse texto com outros valores para construir uma mensagem.

Una valores em texto

String firstName = "Ada";
String lastName = "Lovelace";
System.out.println(firstName + " " + lastName);

A saída é “Ada Lovelace”. O literal do meio fornece o espaço. Sem ele, firstName + lastName produziria “AdaLovelace”. A concatenação não acrescenta separadores para você.

Concatenação significa unir valores em uma nova cadeia de caracteres. Se um dos operandos de + for uma String, Java converte o outro valor em texto e os une. Assim, "Age: " + 36 se torna “Age: 36”, e "Price: " + 2.5 se torna “Price: 2.5”. Os algarismos no resultado agora fazem parte de um valor de texto.

String começa com S maiúsculo. Diferentemente dos oito tipos primitivos, ela é uma classe. Escrever string name = "Ada"; com s minúsculo falha na compilação. A cadeia de caracteres vazia "" é um texto válido sem caracteres; ela não é um valor ausente.

Acompanhe os sinais de adição da esquerda para a direita

Considere:

System.out.println("Sum: " + 2 + 3);

O primeiro + une a String e 2, formando “Sum: 2”. O segundo une essa String e 3, formando “Sum: 23”. Quando o resultado acumulado é texto, o próximo + continua unindo texto.

Compare três formas:

Use parênteses quando uma mensagem deve conter o resultado de uma adição ou subtração. Por exemplo, "Diff: " + (5 - 2) produz “Diff: 3”. Sem os parênteses, "Diff: " + 5 - 2 tenta subtrair 2 de uma String e falha na compilação.

Multiplicação e divisão têm precedência maior que +. A expressão "Area: " + 4 * 5 calcula o produto primeiro e produz “Area: 20”.

Construa uma mensagem em etapas

String message = "Hi";
message += "!";

A variável atualizada contém “Hi!”. Para uma String, += acrescenta texto ao atribuir o resultado da união novamente à variável. Você pode montar uma mensagem curta com várias instruções e exibi-la uma vez ao final.

Tenha cuidado com caracteres. Dois operandos char não acionam a concatenação de String. 'A' + 'B' soma seus códigos numéricos, 65 e 66, produzindo o int 131. Começar com a String vazia muda a sequência: "" + 'A' + 'B' primeiro cria “A”, depois “AB”. As aspas determinam os tipos dos operandos, então também determinam o significado de +.

Uma expressão combina valores para produzir um resultado. Java a avalia de acordo com a precedência de operadores, e uma instrução pode então armazenar ou exibir esse resultado.

Escreva as operações explicitamente

Os operadores aritméticos são +, -, *, / e %: adição, subtração, multiplicação, divisão e resto. Com int width = 4; e int height = 5;, width * height é avaliado como 20.

Toda multiplicação precisa de *. A forma semelhante à álgebra 2(3 + 4) é inválida em Java; escreva 2 * (3 + 4). Java não tem operador aritmético de potência. 2 ^ 3 significa uma operação bit a bit e produz 1, não 8. Para elevar um valor ao quadrado, escreva x * x; para calcular outra potência, use Math.pow.

Aplique a precedência antes de ler da esquerda para a direita

No mesmo nível, esses operadores aritméticos se agrupam da esquerda para a direita. 2 + 3 * 4 é 14; (2 + 3) * 4 é 20. Em 10 - 4 - 3, a primeira subtração produz 6 e a segunda produz 3. Em 24 / 4 * 2, a divisão produz 6 e a multiplicação produz 12. Para tratar o denominador como 4 * 2, seriam necessários parênteses.

Calcule uma média corretamente

Suponha int a = 7, b = 8, c = 10;. A expressão a + b + c / 3 divide apenas c. A divisão inteira faz 10 / 3 ser igual a 3, e as adições produzem então 18.

(a + b + c) / 3 agrupa o total inteiro, 25, mas ambos os operandos de / são inteiros. O resultado é 8. Usar (a + b + c) / 3.0 mantém a parte fracionária e produz 8.333333333333334.

Os tipos dos operandos controlam a aritmética. Dois operandos int produzem um resultado int. Um operando double faz com que o outro operando numérico seja convertido para double, como em 5 * 2.0, cujo resultado é 10.0. A variável de destino não muda como a operação aritmética anterior foi feita.

Atualize um valor armazenado

int total = 10;
total += 5;
total *= 2;
total--;

Os valores armazenados passam a ser 10, 15, 30 e 29. Para esses operandos int, total += 5; realiza a mesma atualização que total = total + 5;. Os operadores -=, /= e %= combinam de modo semelhante uma operação com uma atribuição. count++; aumenta uma variável em 1, e count--; a diminui em 1. Usados como instruções separadas, seus efeitos são fáceis de acompanhar.

Uma expressão como a + b não altera nenhum dos operandos. Para usar seu resultado, atribua-o ou passe-o a uma chamada de exibição: int sum = a + b; ou System.out.println(a + b);. A linha isolada a + b; não compila porque Java não permite essa expressão aritmética como instrução independente. Atribuições, incrementos, decrementos e chamadas de métodos podem ser independentes e podem produzir efeitos.

A divisão inteira responde quantos grupos completos cabem. O resto informa o que sobra. Juntas, essas operações dividem uma quantidade em partes úteis.

Preveja o quociente e o resto

Quando ambos os operandos são inteiros, / descarta a parte fracionária, aproximando o resultado de zero. 7 / 2 é 3, 2 / 3 é 0 e -7 / 2 é −3. Isso é truncamento, não arredondamento para o inteiro mais próximo.

O operador de resto % retorna o que sobra após a divisão. 17 / 5 produz 3, e 17 % 5 produz 2. Três grupos de 5 correspondem a 15, deixando 2. Para operandos inteiros e um divisor diferente de zero, (a / b) * b + a % b reconstrói a usando aritmética inteira de Java.

O sinal de um resto diferente de zero segue o operando à esquerda: -7 % 3 é −1, enquanto 7 % -3 é 1. Para inteiros não negativos, n % 2 é 0 para valores pares e 1 para valores ímpares.

Divida segundos em unidades maiores

Comece com 3725 segundos:

int totalSeconds = 3725;
int hours = totalSeconds / 3600;
int secondsAfterHours = totalSeconds % 3600;
int minutes = secondsAfterHours / 60;
int seconds = secondsAfterHours % 60;

A primeira divisão encontra 1 hora completa. O resto é 125 segundos. Dividir esse resto por 60 encontra 2 minutos, com 5 segundos restantes. O resultado é 1 h 2 min 5 s. A recomposição do total fornece 3600 segundos mais 120 segundos mais 5 segundos, ou 3725.

Use o resto após retirar as horas para encontrar os minutos dentro da hora atual. Dividir o total original por 60 produziria todos os 62 minutos completos, incluindo os minutos já contados como uma hora.

Os mesmos operadores extraem algarismos decimais de um inteiro não negativo. 4827 % 10 fornece o último algarismo, 7; 4827 / 10 fornece os algarismos iniciais restantes, 482.

Distinga grupos completos de recipientes suficientes

Para 50 ovos e caixas com capacidade para 12 ovos, 50 / 12 produz 4 caixas cheias e 50 % 12 produz 2 ovos restantes. Acomodar todos os ovos exige uma quinta caixa. Para quantidades não negativas e capacidades positivas de caixa, a expressão inteira (count + size - 1) / size arredonda a quantidade de recipientes para cima, desde que a adição não cause estouro. Neste exemplo, (50 + 12 - 1) / 12 produz 5.

Escolha a divisão fracionária antes que ela aconteça

Um destino double não pode recuperar uma fração descartada. Torne um operando double antes de dividir quando precisar da fração.

A divisão ou o cálculo do resto por zero inteiro lança ArithmeticException durante a execução. A divisão em ponto flutuante se comporta de outra forma: 5.0 / 0 produz Infinity, -5.0 / 0 produz -Infinity e 0.0 / 0 produz NaN, que significa “não é um número”. Portanto, um resultado pode ser inutilizável mesmo quando a execução não para.

A aritmética decimal é útil para medidas e médias. A classe Math acrescenta cálculos prontos, enquanto o arredondamento permite escolher como armazenar ou apresentar um resultado.

Mantenha frações e reconheça aproximações

150 / 2.5 produz 60.0, uma velocidade em km/h quando a distância é de 150 km e o tempo é de 2,5 horas. Como um operando é double, a divisão mantém um resultado fracionário quando necessário. Valores double inteiros comuns são exibidos com uma parte decimal, como 60.0.

Um double armazena uma aproximação binária de muitos valores decimais. Consequentemente, 1.1 * 3 exibe 3.3000000000000003, e 10.0 / 3 exibe 3.3333333333333335. Mantenha o valor de trabalho nos cálculos posteriores e arredonde-o ao apresentá-lo.

Valores grandes ou pequenos podem ser exibidos em notação científica. 1.23456789E7 representa 12.345.678,9, e 1.0E-4 representa 0,0001. Para valores positivos finitos, a notação comum é usada de 0,001 até 10.000.000, sem incluir esse último. A notação científica altera a forma exibida, não o valor subjacente.

Chame métodos úteis de Math

Math está em java.lang, portanto não é necessária uma importação.

Math.sqrt e Math.pow retornam double. A constante Math.PI é aproximadamente 3,141592653589793. Para um círculo com raio de 2,5 cm, Math.PI * 2.5 * 2.5 produz 19.634954084936208 cm², cerca de 19,63 cm². Para um triângulo retângulo com catetos de 3 cm e 4 cm, Math.sqrt(3 * 3 + 4 * 4) primeiro soma os quadrados dos catetos para obter 25 e depois produz 5.0 cm.

Escolha uma direção de arredondamento

round escolhe o inteiro mais próximo, com valores exatamente no meio seguindo em direção ao infinito positivo. floor arredonda para baixo, em direção ao infinito negativo; ceil arredonda para cima, em direção ao infinito positivo. Para negativos, “para baixo” significa um valor mais negativo, então aplicar a função piso a −2,7 produz −3,0.

Para um argumento double, Math.round retorna um long. Armazene esse resultado em um long ou converta-o explicitamente quando um int for adequado: int rounded = (int) Math.round(2.7); armazena 3. floor e ceil retornam valores double.

Para arredondar um valor armazenado para duas casas decimais, use Math.round(12.3456 * 100) / 100.0, que produz 12.35. A etapa de multiplicação coloca a casa dos centésimos no limite dos números inteiros. Dividir por 100.0 reduz a escala por meio de divisão em ponto flutuante; dividir pelo inteiro 100 descartaria a fração e produziria 12. Se apenas o texto exibido precisar de arredondamento, printf pode formatar diretamente o valor original.

Às vezes, Java converte um valor numérico automaticamente. Outras conversões precisam de uma conversão explícita de tipo. Uma conversão explícita altera o tipo de um valor em um ponto específico de uma expressão, então sua posição afeta a resposta.

Amplie automaticamente

O principal caminho de ampliação numérica é byte → short → int → long → float → double. Um char também é ampliado para int e tipos posteriores. Por exemplo, double d = 5; armazena 5.0, e qualquer valor int cabe exatamente em um long.

A ampliação para um tipo em ponto flutuante pode perder precisão. Conversões de int para float, de long para float e de long para double podem arredondar um inteiro grande. A conversão de um int para um double é exata. Por exemplo, (float) 16777217 se torna 1.6777216E7, que representa 16.777.216.

Use uma conversão explícita no estreitamento

Uma conversão explícita de tipo escreve o tipo de destino entre parênteses antes do valor:

int n = (int) 3.99;

O resultado armazenado é 3. Sem (int), Java rejeita a atribuição do literal double a um int. Converter um double finito e dentro do intervalo para um inteiro trunca em direção a zero: (int) -3.99 também produz −3. O truncamento difere do arredondamento; (int) Math.round(3.99) produz 4.

Conversões de estreitamento geralmente precisam de uma conversão explícita. Uma exceção útil permite que uma expressão inteira constante que caiba no tipo inicialize um byte, short ou char. Assim, byte b = 100; é válido sem (byte). Uma variável int não constante não recebe essa exceção para atribuição de constante simplesmente porque seu valor atual cabe no tipo.

Coloque a conversão explícita antes da operação que precisa dela

Considere int sum = 25; e int count = 3;.

Uma conversão explícita tem precedência maior que a multiplicação e a divisão. Os parênteses determinam se ela se aplica a um operando ou a um cálculo concluído. Converter após a divisão inteira não recupera informações descartadas.

Preveja alterações em caracteres e inteiros de tipos menores

(int) 'A' fornece seu código de caractere, 65. Somar 1 a 'A' produz o int 66. Para transformar o resultado completo novamente em um caractere, escreva (char) ('A' + 1), que produz 'B'. Sem os parênteses externos em torno da soma, a conversão explícita se aplicaria apenas a 'A'.

O estreitamento entre tipos inteiros mantém apenas os bits menos significativos. (byte) 200 se torna −56; (int) 3_000_000_000L se torna −1294967296. Uma conversão explícita permite a conversão, mas não verifica se o valor original cabe no tipo.

A atribuição composta tem uma conversão integrada para o tipo à esquerda. Com int x = 10;, x += 2.7; calcula 12,7 e o converte por estreitamento para 12. A atribuição simples x = x + 2.7; falha porque seu lado direito é double.

Um texto pode conter algarismos sem ser um número. Para calcular com texto digitado ou armazenado, analise-o e converta-o em um tipo numérico. Para construir uma mensagem, converta um valor numérico de volta em texto.

Converta texto antes de calcular

A expressão "42" + 1 produz “421”. Como o operando à esquerda é uma String, + realiza uma concatenação. Integer.parseInt("42") + 1 produz 43 porque a análise e conversão de texto fornece um int antes da adição.

String first = "12";
String second = "30";
int total = Integer.parseInt(first) + Integer.parseInt(second);

Aqui, total contém 42. Unir as cadeias de caracteres originais produziria “1230”. Escolha a conversão com base no uso pretendido do valor, não no fato de seus caracteres parecerem numéricos.

Integer.parseInt(text) retorna um int; Long.parseLong(text) retorna um long. Integer.valueOf("42") retorna um objeto Integer, que Java converte automaticamente para int quando um int é necessário. Para uma operação direta de texto para int, parseInt indica claramente o resultado pretendido.

Converta decimais e valores lógicos

Double.parseDouble("3.75") retorna o double 3,75. Seu formato de texto usa ponto decimal em todos os computadores, independentemente das configurações regionais. Double.parseDouble("3,5") falha. Literais no código-fonte Java também usam ponto, embora métodos de leitura pelo teclado possam seguir uma configuração regional.

Boolean.parseBoolean(text) segue uma regra separada: retorna true para “true” em qualquer combinação de letras maiúsculas e minúsculas, como “TRUE”. Qualquer outro texto retorna false, incluindo “yes”. Ele não interpreta uma palavra afirmativa qualquer como verdadeira.

Reconheça texto numérico inválido

Texto numérico inválido causa uma NumberFormatException durante a execução do programa. Integer.parseInt("4.5") falha porque texto decimal não é uma representação de inteiro. Integer.parseInt("") e Integer.parseInt(" 42") também falham. A mensagem da exceção identifica o texto que não pôde ser convertido.

O tratamento de espaços em branco depende do método de conversão. Double.parseDouble ignora espaços no início e no fim, enquanto Integer.parseInt não. Escolha entradas de teste que revelem essas diferenças ao ler dados do usuário.

Um padrão conveniente de entrada é ler uma linha inteira e convertê-la:

int age = Integer.parseInt(scanner.nextLine());
double height = Double.parseDouble(scanner.nextLine());

Cada chamada consome sua linha inteira, incluindo o terminador de linha. Isso mantém a entrada de texto e de números consistente e evita misturar leituras de unidades de entrada com leituras de linhas inteiras.

Transforme um número em texto

String.valueOf(42), Integer.toString(42) e "" + 42 produzem a String “42”. Double.toString(2.50) produz “2.5”. A escrita decimal original não permanece associada ao número armazenado, então essa conversão não acrescenta um zero ao final para preservá-la.

Use String.format quando precisar de texto armazenado com uma quantidade fixa de casas decimais. Use printf quando quiser exibir diretamente esse texto formatado. Uma conversão numérica explícita ou uma concatenação básica não fornece uma exibição fixa com duas casas.

A entrada pelo teclado chega como texto. Um Scanner pode ler uma linha inteira, uma palavra ou uma palavra convertida em número. Escolha um plano de leitura consistente antes de solicitar valores ao usuário.

Crie um Scanner e leia uma linha

import java.util.Scanner;

public class Greeting {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("What is your name? ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

A importação fica antes da classe. A instrução de criação fica dentro de main e conecta o Scanner a System.in. Um Scanner é suficiente para esse programa. nextLine() espera pela linha digitada e retorna seu texto sem a quebra de linha. Digitar “Ada” faz a última instrução exibir “Hello, Ada!”. Usar print para a solicitação mantém a digitação ao lado da pergunta.

Escolha linhas ou unidades de entrada

Para “Ada Lovelace”, next() retorna “Ada”. Uma chamada posterior de nextLine() retorna “ Lovelace”, incluindo o espaço inicial. Duas chamadas de nextInt() podem ler “3 4” de uma linha. Uma unidade de entrada numérica incompatível com o método, como “4.5” ou “abc” para nextInt(), causa uma InputMismatchException.

Considere o terminador de linha não lido

Suponha que o usuário digite “30”, pressione Enter, depois digite “Ada Lovelace” e pressione Enter. Este código não lê o nome como pretendido:

int age = scanner.nextInt();
String name = scanner.nextLine();

nextInt() consome 30, mas deixa o terminador de linha. nextLine() consome imediatamente o restante vazio dessa mesma linha, então name é "". Acrescente scanner.nextLine(); entre as duas instruções para descartar esse restante antes de ler o nome na próxima linha.

Outra solução é ler cada resposta com nextLine() e converter as linhas numéricas: int age = Integer.parseInt(scanner.nextLine());. Isso evita alternar entre duas unidades de entrada diferentes.

Deixe clara a convenção decimal

nextDouble() segue a configuração regional do Scanner, inicialmente a configuração regional de formatação padrão do computador. Uma configuração com vírgula decimal aceita “3,5” como decimal e rejeita “3.5” neste exemplo. Para ler decimais com ponto de forma consistente, acrescente import java.util.Locale; e crie:

Scanner scanner = new Scanner(System.in).useLocale(Locale.US);

Ler uma linha inteira com Double.parseDouble(scanner.nextLine()) também usa ponto. Alterar a configuração regional do Scanner não altera os literais do código-fonte Java nem a configuração regional usada por chamadas posteriores de printf.

Leia os valores na ordem pedida pelas solicitações. Se você pedir um nome e depois uma idade, a primeira leitura deve armazenar o nome. Uma leitura fora de lugar pode colocar dados na variável errada ou causar um erro de conversão.

A saída formatada controla como os valores aparecem em uma mensagem. printf pode mostrar uma quantidade fixa de casas decimais, acrescentar uma quebra de linha e alinhar valores em colunas sem alterar seus valores armazenados.

Associe marcadores aos valores

Uma cadeia de formatação contém texto comum e especificadores que começam com %. Cada especificador que consome um valor recebe o próximo valor fornecido após a cadeia de formatação:

System.out.printf("%s is %d years old%n", "Ada", 36);

Isso exibe “Ada is 36 years old” e inicia uma nova linha. %s exibe texto ou outro valor como texto, %d exibe um inteiro como int ou long, e %f exibe um valor em ponto flutuante. %n insere uma quebra de linha sem consumir um valor. %% exibe um sinal de porcentagem.

printf não acrescenta uma quebra de linha automaticamente. Inclua %n quando a próxima saída tiver que começar em uma nova linha. A sequência de escape comum \n também representa um caractere de nova linha dentro de texto Java; %n é o separador de linha específico da plataforma usado pelo formatador.

Defina as casas decimais para exibição

%f sem precisão exibe seis casas após o separador decimal: formatar 2.5 produz “2,500000”. A precisão em %.2f solicita duas casas:

System.out.printf("Total: %.2f%n", 12.3456);

Com a formatação dos Estados Unidos, a saída é “Total: 12.35”. O valor é arredondado no texto exibido. Uma variável que contém 12,3456 continua contendo esse valor de trabalho após a exibição.

Para System.out.printf("%d items at %.2f each, total %.2f%n", 3, 1.5, 3 * 1.5);, os valores preenchem os três marcadores em ordem. Com configurações dos Estados Unidos, a saída é “3 items at 1.50 each, total 4.50”.

Alinhe campos com largura

A largura é um tamanho mínimo de campo. %5d alinha um inteiro à direita em pelo menos cinco caracteres; %-6s alinha texto à esquerda em pelo menos seis. %6.1f combina largura 6 com uma casa decimal.

System.out.printf("[%5d][%-6s][%6.1f]%n", 42, "Ada", 9.25);

Com configurações dos Estados Unidos, a saída exata é [ 42][Ada ][ 9.3]. Os colchetes tornam visíveis os espaços de preenchimento. Um valor maior que sua largura ainda é exibido por completo; a largura não corta caracteres.

Um especificador incompatível causa um erro de execução. printf("%d%n", 2.5) compila, mas lança IllegalFormatConversionException porque %d espera um valor inteiro. Valores insuficientes, como em printf("%d %d%n", 2), causam MissingFormatArgumentException.

Escolha entre exibir e armazenar texto

String.format aplica as mesmas regras de formatação, mas retorna uma String:

String line = String.format("%.1f km", 12.345);

Com configurações dos Estados Unidos, line contém “12.3 km”; essa instrução não exibiu nada.

Ambos os métodos de formatação usam a configuração regional padrão, a menos que você informe uma. Acrescente import java.util.Locale; e use System.out.printf(Locale.US, "%.2f%n", 12.3456); para garantir “12.35” em vez de “12,35”, usado por uma configuração regional com vírgula decimal. String.format também pode receber Locale.US primeiro. Exibir um double com println usa ponto independentemente da configuração regional de formatação.

Um programa de cálculo completo conecta três etapas: ler as entradas, fazer cálculos com elas e exibir os resultados. Planejar os valores e suas unidades antes de digitar ajuda você a escolher tipos e testar o resultado.

Planeje um programa de tempo de viagem

As entradas são distância em quilômetros e velocidade média em km/h. Dividir a distância pela velocidade fornece o tempo em horas. Ambas as medidas precisam de double para que a divisão possa manter uma fração. A saída será em horas e minutos inteiros, arredondados para o minuto mais próximo.

import java.util.Scanner;

public class TravelTime {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Distance (km): ");
        double distance = Double.parseDouble(scanner.nextLine());
        System.out.print("Speed (km/h): ");
        double speed = Double.parseDouble(scanner.nextLine());
        int totalMinutes = (int) Math.round(distance / speed * 60);
        int hours = totalMinutes / 60;
        int minutes = totalMinutes % 60;
        System.out.println("Travel time: " + hours + " h " + minutes + " min");
    }
}

Para 150 km a 80 km/h, a divisão produz 1,875 hora. A multiplicação por 60 produz 112,5 minutos. Math.round retorna o long 113, e a conversão explícita o converte para int. A divisão inteira e o resto produzem então 1 hora e 53 minutos. A saída é “Travel time: 1 h 53 min”.

Se distância e velocidade fossem ambas int, 150 / 80 * 60 produziria 60. A fração desaparece na divisão, antes da multiplicação. As escolhas de tipos fazem parte do plano, não apenas da instrução final de saída.

Escolha exibição e aritmética separadamente

Para um total de conta de 87,60 dividido entre 4 pessoas, armazene o total em double e a quantidade em int. double share = total / people; produz 21,9. Com a formatação dos Estados Unidos, System.out.printf("Each person pays %.2f%n", share); exibe “Each person pays 21.90”. A formatação fornece a segunda casa decimal sem alterar o cálculo.

Para as notas inteiras 7, 8 e 10, double average = (a + b + c) / 3.0; produz 8.333333333333334, exibido como “8,33” com %.2f. Os parênteses agrupam o total e o divisor decimal mantém sua fração.

Teste com resultados que você conhece

Calcule os resultados esperados antes de executar o programa. Para o tempo de viagem, 120 km a 60 km/h deve produzir 2 h 0 min. Uma distância de 0 km a uma velocidade positiva deve produzir 0 h 0 min. Experimente entradas próximas a um limite de arredondamento e distâncias válidas maiores para exercitar mais do que o cálculo mais simples.

Inclua entradas zero, negativas e grandes ao verificar o comportamento do programa. Decida se cada entrada faz sentido para a tarefa. Uma quantidade de zero pessoas faz total / people produzir Infinity quando total é um double diferente de zero; a divisão inteira por zero lança ArithmeticException. A execução bem-sucedida, por si só, não garante uma resposta útil.

Quando a saída diferir do que você esperava, exiba os valores intermediários ou acompanhe-os em uma tabela. Encontre o primeiro valor incorreto, corrija a instrução responsável e execute novamente os testes conhecidos. Compare espaços e rótulos, além dos números.

Use nomes como totalMinutes, constantes nomeadas como MINUTES_PER_HOUR, unidades nas solicitações e comentários curtos que expliquem a finalidade de um cálculo.