3. Fundamentos da linguagem Java
3.1. Introdução
Começaremos tratando o Java como uma linguagem de programação tradicional. Abordaremos as classes no próximo capítulo. Um programa é composto de duas coisas:
- dados;
- as instruções que os manipulam.
Procuramos, em geral, separar os dados das instruções:

Todos os exemplos deste capítulo são arquivos-fonte compactos: um único arquivo chamado [.java], sem projeto Maven, executado com o comando [java Basics01.java]. O launcher [java] então compila o arquivo em memória e o executa, sem produzir um arquivo [.class]. Essa capacidade foi introduzida no Capítulo 2, “Configuração do ambiente de desenvolvimento”. Os exemplos estão na pasta [03-basics] do código do curso. Eles são executados com a língua e as convenções do francês (o “locale” fr-FR), como seriam em uma máquina Windows em francês. Veremos que isso afeta apenas os números e as datas formatados com um formato específico: a simples conversão de um número de ponto flutuante em string usa sempre o ponto decimal.
3.2. O programa mínimo
3.2.1. O arquivo-fonte compacto
O programa [Basics01.java] é o seguinte:
Resultados:
Comentários:
- O arquivo não contém nenhuma declaração de classe, apenas um método chamado [main]. Trata-se de um arquivo-fonte compacto (Java 25). O próprio compilador envolve o conteúdo do arquivo em uma classe declarada implicitamente, que leva o nome do arquivo: [Basics01]. Esse recurso foi introduzido como preview do Java 21 ao Java 24 antes de se tornar definitivo no Java 25;
- linha 3: o método [main] é o ponto de entrada do programa: é esse método que o launcher [java] executa. A partir do Java 25, ele pode ser escrito simplesmente como [void main()], sem as palavras-chave [public] e [static] e sem nenhum parâmetro. O corpo do método é delimitado por chaves;
- linha 4: o método [println] da classe [IO] (Java 25) escreve uma linha na tela;
- linha 6: a forma tradicional da mesma operação. [System] é uma classe, [out] é um de seus campos, que representa a saída padrão (a tela), e [println] é um método desse objeto. [IO.println(x)] é simplesmente um atalho para [System.out.println(x)]. Usaremos [IO.println] nos arquivos compactos e [System.out.println] nas classes comuns, onde aparece em todo o código Java existente;
- linha 8: [List] é uma lista de strings; as listas serão tratadas no Capítulo 5. [List] pertence ao pacote [java.util]: um pacote agrupa classes relacionadas, assim como uma pasta agrupa arquivos. O nome completo da classe é [java.util.List]. Ela pode ser usada sem uma instrução import porque o arquivo é um arquivo compacto (veja abaixo);
- linha 9: uma lista é exibida com seus elementos entre colchetes;
- cada instrução termina com um ponto e vírgula; as linhas iniciadas por // são comentários, ignorados pelo compilador.
Com dois argumentos de linha de comando (colocados após o nome do arquivo):
Os argumentos são ignorados porque o método [void main()] não tem parâmetros para recebê-los. Para usá-los, declare-o como [void main(String[] args)]: o array de strings [args] passa então a conter os argumentos da linha de comando. Voltaremos a isso na seção “Argumentos do programa principal”.
3.2.2. A forma clássica com uma classe e um método main
Até o Java 24, o mesmo programa precisava ser escrito assim: [Basics02.java]:
Resultados:
Comentários:
- linha 2: a diretiva [import] importa a classe [Arrays] do pacote [java.util]. Você pode então escrever [Arrays] em vez de [java.util.Arrays]. Em uma classe comum, apenas as classes do pacote [java.lang] ([System], [String], [Math], [Integer], [IO]...) podem ser usadas sem importação;
- linha 4: em Java, todo código pertence a uma classe. Aqui, a classe se chama [Basics02]. Uma classe declarada como [public] deve estar em um arquivo com esse nome: [Basics02.java];
- linha 6: o método [main] é o ponto de entrada do programa. Ele é [public] (acessível de fora da classe, em particular pelo launcher [java]), [static] (executa sem exigir a criação de um objeto da classe), não retorna resultado ([void]) e recebe os argumentos da linha de comando no array [args];
- linha 8: o número de elementos do array [args] é [args.length]. O operador + concatena aqui uma string e um número: o número é primeiro convertido em string;
- linha 10: o método [Arrays.toString] constrói uma string a partir dos elementos de um array.
Um arquivo contendo uma classe comum também pode ser executado diretamente pelo launcher ([java Basics02.java]). Também é possível compilá-lo antes com o compilador [javac], que produz um arquivo [Basics02.class] contendo o código intermediário (“bytecode”) da classe, e depois executar essa classe com o comando [java] seguido do nome da classe (sem a extensão). É o que o Maven e os ambientes de desenvolvimento fazem nos bastidores:
Os dois programas [Basics01.java] e [Basics02.java] são equivalentes na essência. Ao encontrar um arquivo compacto, o próprio compilador gera uma classe [final] com o nome do arquivo, cujos métodos e campos são os escritos no arquivo. O arquivo compacto é, portanto, apenas uma forma abreviada da forma padrão. Ele é adequado aos pequenos programas deste capítulo; a forma padrão se torna necessária assim que um programa contém várias classes, o que acontecerá a partir do Capítulo 4.
Desde o Java 25, o método [main] pode ter quatro formas: [static void main(String[] args)], [static void main()], [void main(String[] args)], e [void main()]; se uma classe contém várias delas, o launcher prefere a que tem o parâmetro [String[]]. As duas últimas formas são métodos de instância: o launcher primeiro cria um objeto da classe e depois chama seu método [main]. A palavra-chave [public] não é mais obrigatória.
3.2.3. Importação automática do módulo java.base
O programa [Basics01.java] usa a classe [List] sem a diretiva [import java.util.List;]. Isso é possível porque o compilador adiciona automaticamente a seguinte diretiva a todo arquivo compacto (Java 25):
As classes da biblioteca padrão do Java são organizadas em pacotes, que por sua vez são agrupados em módulos. O módulo [java.base] é o módulo central: ele contém os pacotes mais usados. A diretiva [import module java.base;] importa de uma só vez todas as classes públicas de todos os pacotes exportados por esse módulo, o que equivale, entre outras coisas, às seguintes diretivas:
Em um arquivo compacto, você tem portanto acesso, sem escrever uma única linha de código, a listas e dicionários ([java.util]), arquivos ([java.io], [java.nio.file]), números grandes ([java.math]), datas ([java.time]) etc. Uma classe de outro módulo, como as classes JDBC do módulo [java.sql], deve sempre ser importada explicitamente. Em uma classe comum, nada é importado automaticamente fora do pacote [java.lang]: escreve-se uma diretiva por classe ([import java.util.Arrays;]), uma diretiva por pacote ([import java.util.*;]) ou, desde o Java 25, uma diretiva por módulo ([import module java.base;]). A classe [IO] faz parte do pacote [java.lang]: ela pode ser usada em qualquer lugar.
3.3. Os dados em Java
O Java usa os seguintes tipos de dados:
- números inteiros;
- números reais;
- números decimais;
- caracteres e strings;
- booleanos;
- objetos.
3.3.1. Tipos de dados predefinidos
Tipo Java | Classe wrapper | Dados representados | Sufixo do literal | Codificação | Intervalo de valores |
[char] | [Character] | caractere | 2 bytes | Caractere Unicode (UTF-16), de '\u0000' a '\uffff' | |
[byte] | [Byte] | inteiro | 1 byte | [-2⁷, 2⁷-1], ou [-128, 127] | |
[short] | [Short] | inteiro | 2 bytes | [-2¹⁵, 2¹⁵-1] ou [-32768, 32767] | |
[int] | [Integer] | inteiro | 4 bytes | [-2³¹, 2³¹-1] ou [-2147483648, 2147483647] | |
[long] | [Long] | inteiro | L | 8 bytes | [-2⁶³, 2⁶³-1] ou [-9223372036854775808, 9223372036854775807] |
[float] | [Float] | número real | F | 4 bytes | [1.4 10⁻⁴⁵, 3.4 10³⁸] em valor absoluto, 7 dígitos significativos |
[double] | [Double] | número real | D (opcional) | 8 bytes | [4.9 10⁻³²⁴, 1.8 10³⁰⁸] em valor absoluto, 15 a 16 dígitos significativos |
[boolean] | [Boolean] | booleano | Indefinido | [true], [false] | |
[String] (classe) | string | referência a uma sequência de caracteres Unicode | |||
[BigDecimal] (classe) | número decimal | variável | número decimal exato, de precisão arbitrária | ||
[Object] (classe) | referência a objeto | referência a um objeto de qualquer tipo |
Os oito primeiros tipos da tabela, cujos nomes são escritos em minúsculas, são os tipos primitivos do Java. Todos os outros tipos são tipos de referência: classes ([String], [BigDecimal], [Object]...), bem como arrays, enumerações, interfaces e records, que veremos mais adiante. A diferença é fundamental:
- uma variável de tipo primitivo contém diretamente seu valor;
- uma variável de tipo de referência contém o endereço do objeto (sua referência), e o próprio objeto fica armazenado em outro lugar da memória.
Um valor de tipo primitivo não é um objeto: ele não tem campos nem métodos. No entanto, cada tipo primitivo corresponde a uma “classe wrapper” do pacote [java.lang]: [Integer] para [int], [Double] para [double], [Character] para [char] e assim por diante. Um objeto [Integer] encapsula um valor [int]. Essas classes também oferecem constantes e métodos úteis: [Integer.MAX_VALUE], [Integer.BYTES], [Integer.parseInt]... Desde o Java 5, o compilador converte automaticamente um tipo primitivo em sua classe wrapper (boxing) e vice-versa (unboxing). Assim, podemos escrever:
O literal 3 é do tipo [int]. Como ele não tem métodos, não podemos escrever [3.getClass()]: é preciso primeiro encapsulá-lo em um objeto [Integer] com [Integer.valueOf(3)]. Todo objeto tem um método [getClass()] que retorna um objeto descrevendo sua classe; o método [getName()] desse objeto retorna o nome completo da classe, neste caso [java.lang.Integer].
O Java não tem inteiros sem sinal, exceto o tipo [char] (16 bits). As classes wrapper, por outro lado, oferecem métodos que interpretam os bits de um inteiro como os de um número sem sinal: [Integer.toUnsignedString], [Integer.parseUnsignedInt], [Integer.compareUnsigned], [Byte.toUnsignedInt]... Ele também não tem um tipo decimal primitivo: os valores monetários são calculados com a classe [BigDecimal] do pacote [java.math], que veremos um pouco mais adiante.
O programa [Basics03.java] ilustra esses vários pontos:
Resultados:
Comentários:
- linha 3: declaração de um inteiro [integer] inicializado com 2;
- linha 4: o sufixo F é obrigatório: o literal 10.5 é do tipo [double], e o compilador rejeita [float fl = 10.5;], que resultaria em perda de precisão;
- linha 7: o literal 1000 é do tipo [int]; ele é convertido automaticamente em [long];
- linha 12: um número [BigDecimal] é um objeto; aqui ele é criado a partir de uma string, o que garante um valor exato;
- linha 14: o método [formatted] (Java 15) é aplicado a uma string de formato: cada marcador %s é substituído pelo valor do parâmetro correspondente convertido em string, e cada %d pelo valor de um inteiro. Os parâmetros são tomados em ordem. Falaremos dos formatos na próxima seção;
- linha 14: o método [typeName] (linhas 36 a 38) espera um parâmetro do tipo [Object]. A variável [integer], do tipo [int], é encapsulada automaticamente em um objeto [Integer], cuja classe é [java.lang.Integer]: é por isso que a saída mostra as classes wrapper e não os nomes dos tipos primitivos. [Integer.BYTES] (Java 8) é o tamanho em bytes de um [int];
- linha 17: [String] é uma classe, não um tipo primitivo: o tamanho em memória de um objeto não é acessível em Java;
- linha 22: o tamanho de um [boolean] não é definido pela especificação do Java: a classe [Boolean] não tem uma constante [BYTES];
- linha 25: o literal 3 é encapsulado explicitamente em um [Integer];
- linhas 27 a 29: as constantes [MIN_VALUE] e [MAX_VALUE] das classes wrapper definem os limites do intervalo de valores. Atenção: para os números reais, [Double.MIN_VALUE] é o menor valor estritamente positivo (4.9 × 10⁻³²⁴) e não o maior número negativo, que é [-Double.MAX_VALUE];
- linhas 31 e 32: -1 é codificado como 32 bits iguais a 1; interpretados como um inteiro sem sinal, esses 32 bits equivalem a 2³²–1;
- linhas 36 a 38: um método do arquivo compacto. Ele retorna ([return]) uma string ([String]). Os métodos são descritos na seção “Passagem de parâmetros a uma função”.
Observe que os números reais são exibidos com ponto decimal (10.5, -4.6), embora o programa seja executado em francês. A conversão de um número em string por concatenação, com [String.valueOf], [toString] ou o especificador %s, não depende do idioma do usuário: ela produz sempre um ponto decimal. Apenas os formatos numéricos como %f, que veremos adiante, seguem as convenções do idioma.
3.3.2. Notação dos dados literais
Dado | Exemplos de literais |
inteiro [int] (32 bits) | 145, -7, 0xFF (hexadecimal), 0b1010_1010 (binário) |
inteiro [long] (64 bits), sufixo L | 100000L, 1_000_000_000_000L |
ponto flutuante [double], sufixo D opcional | 134.789, -45E-18 (-45 × 10⁻¹⁸), 10D |
real [float], sufixo F | 134.789F, -45E-18F |
número decimal [BigDecimal] | sem literal: [new BigDecimal("100000.50")] |
caractere [char] | 'A', 'b', '\n', '\u00e9' |
string [String] | "today", "c:\\chap1", bloco de texto """...""" |
booleano [boolean] | [true], [false] |
data | [LocalDate.of(1954, 10, 13)] (ano, mês, dia) para 13/10/1954 |
No código-fonte, os números de ponto flutuante são sempre escritos com ponto decimal. Desde o Java 7, os inteiros podem ser escritos em binário (com o prefixo [0b]) e grupos de dígitos podem ser separados pelo caractere _ para melhorar a legibilidade: [1_000_000] é o inteiro um milhão. O sufixo L pode ser escrito em minúscula, mas l se parece demais com o dígito 1. Por fim, cuidado com uma armadilha herdada da linguagem C: um inteiro escrito com 0 à esquerda é interpretado como octal (base 8): 017 é igual a 15.
Um literal string pode conter sequências de escape introduzidas pelo caractere \: "\n" representa o caractere de fim de linha e não a sequência dos dois caracteres \ e n, "\t" representa uma tabulação, "\"" representa aspas duplas e "\\" representa o próprio caractere \. Para escrever o caminho do Windows c:\chap1\paragraph3, é preciso portanto escrever "c:\\chap1\\paragraph3". O Java não tem uma string “bruta” em que o caractere \ seja interpretado como está; em compensação, as classes de arquivo do Java também aceitam o separador / no Windows: "c:/chap1/paragraph3" designa o mesmo arquivo.
Para construir uma string a partir de vários valores, o Java oferece dois métodos:
- a concatenação com o operador +: assim que um dos dois operandos é uma string, o outro é convertido em string;
- os formatos: [String.format(format, value1, value2, ...)], ou, de forma equivalente, [format.formatted(value1, value2, ...)] (Java 15) e, para exibição direta, [System.out.printf(format, value1, ...)]. A string de formato contém marcadores que são substituídos, em ordem, pelos valores seguintes: %s (qualquer valor convertido em string), %d (um inteiro), %f (um número de ponto flutuante), %.2f (um número de ponto flutuante com duas casas decimais), %x ou %X (um inteiro em hexadecimal), %,d (um inteiro com separador de milhares), %e (notação científica), %n (uma quebra de linha), %10s (uma string alinhada à direita em 10 caracteres), %-10s (alinhada à esquerda)... Os formatos numéricos seguem as convenções do idioma do usuário.
O Java não oferece strings “interpoladas” contendo expressões entre chaves: um recurso desse tipo (conhecido como “string templates”) foi proposto como preview no Java 21 e no 22, mas foi retirado depois. A concatenação e a formatação continuam sendo as únicas opções.
Desde o Java 15, é possível escrever uma string em várias linhas com um “bloco de texto”: ele começa com três aspas seguidas de uma quebra de linha e termina com três aspas. Pode conter aspas sem escape. O espaço em branco inicial comum a todas as linhas (inclusive a linha que contém as aspas de fechamento) é removido, o que permite indentar o texto junto com o código. No entanto, as sequências de escape são interpretadas como em uma string comum: é sempre preciso escrever \\ para obter \. Os blocos de texto são muito úteis para escrever JSON, SQL ou HTML.
O programa [Basics04.java] demonstra essas diferentes notações:
Resultados:
Comentários:
- linha 4: [0xFF] é 255 e [0b1010_1010] é 170;
- linha 5: o sufixo L é obrigatório para um literal que ultrapassa o intervalo de [int]. Sem ele, o compilador rejeita a linha com a mensagem [error: integer number too large];
- linha 8: -45E-18 é exibido como -4.5E-17: é o mesmo valor, normalizado. O número de ponto flutuante 10D é exibido como 10.0: a conversão de um [double] em string produz sempre pelo menos uma casa decimal;
- linha 10: um [BigDecimal] preserva o número de casas decimais com que foi escrito: 100000.50, e não 100000.5;
- linha 13: a sequência \u00e9 designa o caractere Unicode de código hexadecimal 00E9, isto é, é;
- linha 17: uma data. A classe [LocalDate] (pacote [java.time], Java 8) representa uma data sem hora. Sua conversão em string usa o formato internacional ISO 8601 (ano-mês-dia), qualquer que seja o idioma. Trataremos das datas no Capítulo 5;
- linha 21: cada \\ representa um único caractere \;
- linha 23: uma quebra de linha e uma tabulação;
- linha 28: uma concatenação. Os parênteses em [(age + 10)] são essenciais: sem eles, os operadores + seriam avaliados da esquerda para a direita, a string receberia primeiro 23 e depois 10, e o resultado seria “he will be 2310 years old”;
- linha 29: o mesmo texto construído com um formato;
- linha 31: alguns especificadores de formato: %.1f (uma casa decimal), %X (hexadecimal em maiúsculas), %,d (separador de milhares). Esses formatos seguem as convenções francesas: vírgula decimal e, como separador de milhares, um espaço fino não separável;
- linha 32: não há especificador para binário; o método [Integer.toBinaryString] faz a conversão;
- linha 33: um formato de data personalizado: dia da semana (EEEE), dia (d), mês por extenso (MMMM), ano (yyyy). Os nomes dos dias e dos meses estão em francês, o idioma do usuário;
- linhas 36 a 41: um bloco de texto de várias linhas. As aspas são escritas como estão. Os oito espaços comuns a todas as linhas foram removidos. A sequência \\ resultou em um único \. Como as aspas de fechamento estão sozinhas em sua linha, o bloco termina com uma quebra de linha: ele é portanto exibido com [IO.print], que não pula para a linha seguinte;
- linhas 44 e 45: um bloco de texto em que as aspas de fechamento vêm logo após o texto; ele não termina com uma quebra de linha. O método [formatted] substitui %s e %d pelos valores de [name] e [age]: essa é a maneira Java de inserir valores em um texto.
3.3.3. Declaração de dados
3.3.3.1. Papel das declarações
Um programa manipula dados caracterizados por um nome e um tipo. Esses dados são armazenados na memória. Quando o programa é compilado, o compilador atribui a cada dado um local de memória caracterizado por um endereço e um tamanho. Ele faz isso com base nas declarações feitas pelo programador. Além disso, essas declarações permitem ao compilador detectar erros de programação. Assim, a operação [x = x * 2;] será apontada como erro se [x] for uma string.
3.3.3.2. Declaração de constantes
Em Java, uma constante é uma variável declarada com a palavra-chave [final]: ela só pode receber um valor uma única vez. A sintaxe é a seguinte:
Uma constante usada em todo o programa é declarada fora dos métodos, como um campo [static final] da classe. Por exemplo:
Por que declarar constantes?
- O programa fica mais fácil de ler se a constante tiver um nome significativo;
- fica mais fácil modificar o programa se a “constante” precisar ser alterada. Assim, se a alíquota do imposto passar para 0.25, a única modificação necessária será na instrução que define seu valor: [static final double VAT_RATE = 0.25;]. Se 0.2 tivesse sido usado explicitamente no programa, seriam necessárias numerosas modificações de instruções.
Por convenção, em Java, o nome de uma constante [static final] é escrito em letras maiúsculas, com as palavras separadas pelo caractere _: [VAT_RATE], [MAX_VALUE]. Uma variável local também pode ser declarada como [final]; nesse caso, ela mantém um nome comum. A palavra [const] é reservada em Java, mas não é usada.
3.3.3.3. Declaração de variáveis
Uma variável é identificada por um nome e associada a um tipo de dado. O Java distingue letras maiúsculas e minúsculas: as variáveis [END] e [end] são diferentes. Por convenção, o nome de uma variável começa com letra minúscula, e cada palavra seguinte começa com letra maiúscula: [priceExclTax], [nbChildren].
As variáveis podem ser inicializadas no momento da declaração. A sintaxe para declarar uma ou mais variáveis é:
em que [type] é um tipo predefinido ou um tipo definido pelo programador. A inicialização é opcional; no entanto, o Java não permite o uso de uma variável local que ainda não recebeu valor (mensagem de erro [variable x might not have been initialized]).
Desde o Java 10, também é possível omitir o tipo de uma variável local usando a palavra-chave [var] no lugar do tipo:
O termo [var] não significa que a variável não tenha um tipo específico: ela tem o tipo do valor que lhe é atribuído, determinado pelo compilador. A inicialização é obrigatória aqui para que o compilador possa inferir o tipo. [var] só pode ser usado para variáveis locais (não para campos nem para parâmetros de métodos). Ele é usado quando o tipo é evidente pelo valor, em particular quando o nome do tipo é longo.
O programa [Basics05.java] é o seguinte:
Resultados:
Comentários:
- linha 3: uma constante de classe. Em um arquivo compacto, uma variável declarada fora dos métodos é um campo da classe implícita;
- linha 7: uma constante local;
- linha 9: o resultado é um [double], exibido com pelo menos uma casa decimal: 120.0;
- linha 12: um valor com tipo explícito;
- linha 13: [getSimpleName()] (linha 33) é o nome curto da classe; [getName()] é seu nome completo. Como no programa anterior, [int] é encapsulado em um [Integer] para ser passado a [typeName];
- linha 15: um valor com tipo implícito. Como 3 é do tipo [int], [j] será do tipo [int]. A exibição mostra [Integer] pela mesma razão da linha 13;
- linha 17: como [LocalDateTime.now()] (a data e a hora atuais) é do tipo [LocalDateTime], [today] será do tipo [LocalDateTime];
- linhas 19 a 22: o tipo inferido depende da forma como o literal é escrito: 3.5 é um [double], 3.5F é um [float] e 10L é um [long];
- linha 26: três variáveis declaradas na mesma linha; apenas [a] e [c] são inicializadas. [b] recebe um valor na linha seguinte.
Uma variável com tipo implícito [var] não pode mudar de tipo depois. Assim, após a linha 17, a instrução [today = "today";] é rejeitada pelo compilador:
3.3.4. Valores ausentes: null, classes wrapper e Optional
Uma variável de tipo primitivo, como [int], sempre contém um valor. Às vezes é útil poder expressar a ausência de um valor: uma idade desconhecida, um campo vazio em um banco de dados. Nesses casos, usamos a classe wrapper: uma variável de tipo [Integer] é uma referência, que pode ser [null], isto é, “nenhum objeto”.
Qualquer variável de tipo de referência pode, de fato, ter o valor [null]: nesse caso, ela não referencia nenhum objeto. Tentar usar um membro dessa variável, por exemplo seu método [length()], causa um erro em tempo de execução, uma [NullPointerException]: é o erro mais comum em Java. Desde o Java 15, a mensagem de erro especifica exatamente qual expressão resultou em [null]. O compilador Java não distingue uma referência que pode valer [null] de uma que não pode; anotações como as do projeto JSpecify ([@Nullable], [@NonNull]), usadas por ferramentas de análise, ajudam a contornar essa deficiência, mas não as usaremos.
Para indicar que um método pode não retornar nada, o Java 8 acrescentou a classe [Optional<T>]: um objeto [Optional<String>] é uma "caixa" que contém uma string ou está vazia. Ele é criado com [Optional.of(value)], [Optional.empty()], ou [Optional.ofNullable(valueOrNull)]; é consultado com [isPresent()], [isEmpty()] (Java 11), [get()], [orElse(defaultValue)]... As classes [OptionalInt], [OptionalLong], e [OptionalDouble] cumprem a mesma função para os tipos primitivos.
Encontraremos o valor [null] já nos primeiros exemplos, pois o método [IO.readln()], que lê uma linha digitada no teclado, retorna [null] quando não há mais nada a ler (fim do fluxo de entrada). O programa [Basics06.java] é o seguinte:
Resultados ao digitar pelo teclado:
Resultados quando o usuário pressiona Ctrl-D (Ctrl-Z seguido de Enter no Windows), o que fecha o fluxo de entrada:
Comentários:
- linha 4: [age] não referencia nenhum objeto;
- linha 7: o [int] 23 é encapsulado automaticamente: o compilador gerou [age = Integer.valueOf(23);] para nós;
- linha 10: o [Integer] é desencapsulado automaticamente: o compilador escreveu [int n = age.intValue();];
- linhas 13 a 19: desencapsular um
*[Integer]*igual a[null]equivale a chamar*[intValue()]em uma referência nula: uma*[NullPointerException]é lançada. A armadilha é ainda mais insidiosa porque nenhuma chamada de método é visível na linha 15. A estrutura [try / catch], que intercepta o erro, é apresentada mais adiante; aqui, é exibido o nome completo da classe da exceção; - linha 22: uma string que não referencia nenhum objeto;
- linha 25: um [Optional] que contém a string "dupont". O método [get()] (linha 27) retorna seu conteúdo; aplicado a um [Optional] vazio, ele lançaria uma exceção [NoSuchElementException];
- linha 26: um [Optional] vazio;
- linha 28: [orElse] retorna o conteúdo do [Optional] ou, se ele estiver vazio, o valor substituto passado como parâmetro;
- linha 31: [IO.readln(prompt)] (Java 25) exibe o prompt sem passar para a linha seguinte e depois lê a linha digitada no teclado. Ele retorna [null] se o fluxo de entrada estiver fechado;
- linha 32: o valor [null] é verificado;
- linha 36: no ramo [else], [line] não é igual a [null]: [line.length()] pode ser usado com segurança.
3.3.5. Conversões entre números e strings
Conversão | Método |
número -> string | [String.valueOf(number)], [Integer.toString(number)], ["" + number], ou um formato como [String.format("%d", number)] |
string -> int | [Integer.parseInt(string)] |
string -> long | [Long.parseLong(string)] |
string -> double | [Double.parseDouble(string)] |
string -> float | [Float.parseFloat(string)] |
string -> BigDecimal | [new BigDecimal(string)] |
string -> boolean | [Boolean.parseBoolean(string)] |
A conversão de uma string em número pode falhar se a string não representar um número válido. O método de conversão gera então um erro chamado exceção, neste caso do tipo [NumberFormatException], que encerra o programa se não for tratado. Esse erro pode ser tratado pela seguinte cláusula [try / catch]:
Se o método não gerar uma exceção, o programa passa para a instrução seguinte; caso contrário, entra no corpo da cláusula [catch] e depois passa para a instrução seguinte. Voltaremos ao tratamento de exceções na seção dedicada a ele.
Os métodos [parseInt], [parseDouble]... aceitam um sinal + ou - no início, mas não espaços nem separadores de milhares: use o método [trim()] da classe [String] para remover os espaços iniciais e finais de uma entrada antes de convertê-la. A biblioteca Java não tem um método que tente uma conversão e retorne um indicador de sucesso em vez de lançar uma exceção; é fácil escrever um que retorne um [OptionalInt] vazio em caso de falha: é o que faz o método [tryParseInt] do programa a seguir.
O programa [Basics07.java] demonstra algumas técnicas de conversão entre números e strings. O método [display] desse programa exibe na tela o valor de seu parâmetro:
Resultados:
Comentários:
- linhas 4–7: os dados a serem convertidos;
- linhas 10–13: quatro maneiras de converter um número em string. A última concatena uma string vazia e o número;
- linha 17: um valor booleano é exibido—[true] ou [false];
- linhas 22–27: trata a exceção que [Integer.parseInt] pode lançar. [e.getMessage()] é a mensagem de erro associada à exceção [e]. As mensagens de exceção do JDK estão em inglês: não são traduzidas;
- linha 40: [Double.parseDouble] sempre espera um ponto decimal, independentemente do idioma do usuário: a string “100.87” é interpretada da mesma forma em todas as máquinas. Esta é a maneira correta de ler números de arquivos ou em trocas entre programas;
- linha 53: consequentemente, a vírgula decimal é rejeitada;
- linha 60: conversão de uma string com [BigDecimal]; este método também espera um ponto decimal;
- linhas 64–71: o método [tryParseInt] (linhas 92–98) retorna um [OptionalInt] que contém o inteiro se a conversão for bem-sucedida e está vazio caso contrário. [getAsInt()] retorna o inteiro contido;
- linha 74: [Locale.getDefault()] retorna o locale do programa—ou seja, o idioma e o país do usuário, conforme determinados pelas configurações do sistema: neste caso, fr-FR;
- linha 75: um formato usa o locale atual: o número de ponto flutuante é escrito com vírgula decimal;
- linha 76: [Locale.ROOT] é um locale neutro que usa o ponto como separador decimal, independentemente da máquina. Ele é usado para escrever números formatados em arquivos ou em trocas entre programas, que não devem depender do idioma do usuário;
- linha 79: para ler um número escrito segundo as convenções francesas, use um objeto [NumberFormat] (pacote [java.text]) obtido para o locale [Locale.FRANCE]. Seu método [parse] retorna um objeto [Number] e pode lançar uma exceção [ParseException]. Trata-se de uma exceção checked: o compilador exige que ela seja tratada, o que explicaremos na seção sobre exceções;
- linhas 87–89: um método do arquivo compacto. Os métodos podem ser escritos em qualquer ordem, antes ou depois de [main];
- linhas 92–98: o método [tryParseInt]. A variável da cláusula [catch] chama-se _: desde o Java 22, esse caractere denota uma variável anônima, que é declarada porque a sintaxe exige, mas não é realmente usada.
Tenha em mente que os métodos [parseXXX] e [toString] ignoram o idioma do usuário (ponto decimal), ao passo que os formatos e a classe [NumberFormat]o respeitam. Um programa que lê números deve sempre saber quais convenções foram usadas para escrevê-los.
3.3.6. Arrays de dados
Um array Java é um objeto que permite agrupar dados do mesmo tipo sob um único identificador. Ele é declarado da seguinte forma:
[n] é o número de elementos de dados que o array pode conter. A sintaxe [array[i]] refere-se ao elemento de dados de número i, onde i pertence ao intervalo [0, n-1]. Qualquer referência ao elemento de dados [array[i]] em que i não esteja no intervalo [0, n-1] causa uma exceção [ArrayIndexOutOfBoundsException]. Na criação, cada elemento do array recebe o valor padrão de seu tipo: 0 para números, [false] para booleanos e [null] para tipos de referência. Um array pode ser inicializado ao mesmo tempo em que é declarado:
ou, de forma mais simples, em uma declaração:
Os arrays têm um campo [length] (sem parênteses) que representa o número de elementos. Um array não pode mudar de tamanho depois de criado: para uma coleção que cresce, usa-se uma lista (Capítulo 5). Encontra-se também a notação [int integers[]], herdada da linguagem C: ela é aceita, mas não recomendada.
Java não possui arrays bidimensionais verdadeiros: um array com dois índices é um array de arrays. A declaração
cria um array de [n] elementos, cada um dos quais é uma referência a um array de [m] elementos: [n] linhas e [m] colunas. A sintaxe [array[i][j]] refere-se ao elemento j da linha i. [array.length] é o número de linhas e [array[i].length] é o número de elementos da linha i. O array também pode ser inicializado ao mesmo tempo em que é declarado:
Como cada linha é um array independente, as linhas podem ter comprimentos diferentes (fala-se então de um array "em escada"). A declaração
cria um array de n elementos, cada um dos quais é uma referência a um array unidimensional. Essas referências não são inicializadas pela declaração acima: elas têm o valor [null].
Java não oferece índices contados a partir do fim do array nem uma notação para extrair um intervalo de elementos. O último elemento é escrito como [array[array.length - 1]], e o método [Arrays.copyOfRange(array, start, end)] retorna um novo array formado pelos elementos com índices de [start] (inclusive) até [end] (exclusive). A classe [java.util.Arrays] oferece muitos outros métodos utilitários: [toString], [deepToString], [sort], [fill], [equals], [copyOf]... As listas, mais flexíveis, possuem os métodos [getFirst()] e [getLast()] desde o Java 21.
O programa [Basics08.java] combina esses diferentes arrays:
Resultados:
Comentários:
- linha 4: um array unidimensional é inicializado;
- linha 5: um laço [for] percorre os índices de 0 a [integers.length - 1]. O laço [for] é apresentado mais adiante;
- linha 10: um array bidimensional (2 linhas, 2 colunas). O inteiro -6 é convertido no número de ponto flutuante -6.0;
- linhas 11–12: [reals.length] é o número de linhas e [reals[i].length] é o número de colunas da linha i;
- linha 16: [Arrays.deepToString] exibe um array de arrays;
- linha 19: um array [names] com 3 elementos. Cada elemento é uma referência a um array do tipo [String[]], atualmente [null];
- linha 21: os 3 elementos do array [names] são inicializados. [names[i]] agora referencia um array de i+1 strings;
- linha 26: [names[i][j]] é o j-ésimo elemento do array referenciado por [names[i]]. A expressão "name" + i + j é avaliada da esquerda para a direita: "name" + i produz uma string, à qual j é concatenado;
- linhas 37–38: arrays criados sem valores iniciais: seus elementos têm o valor padrão de seu tipo;
- linha 42: a forma abreviada de inicialização;
- linha 44: o método [Arrays.toString] constrói uma string a partir dos elementos do array. Exibir o array diretamente ([IO.println(values)]) resultaria em um texto como [I@6328d34a (o tipo do array e um código numérico), em vez de seu conteúdo;
- linha 46: o último e o penúltimo elementos;
- linha 48: os elementos de índices 1 e 2;
- linha 50: os elementos a partir do índice 2 até o fim;
- linhas 53–54: [copyOfRange] cria uma cópia: modificar [slice] não modifica [values];
- linhas 56–57: uma lista não modificável criada por [List.of], e seus métodos [getFirst()] e [getLast()] (Java 21).
3.4. Instruções básicas do Java
Há dois tipos:
- instruções básicas executadas pelo computador;
- instruções que controlam o fluxo do programa.
As instruções básicas ficam claras quando se considera a estrutura de um microcomputador e seus periféricos:

- 1: leitura de informações a partir do teclado;
- 2: processamento das informações;
- 3: escrita de informações na tela.
3.4.1. Escrita na tela
Há várias instruções para escrever na tela:
em que [expression] é qualquer dado que possa ser convertido em uma cadeia de caracteres para exibição na tela. Todos os objetos Java possuem um método [toString()] usado para realizar essa conversão; os valores de tipos primitivos são convertidos por [String.valueOf]. O método [print] faz o mesmo que [println] sem pular para a linha seguinte, e o método [printf(format, value1, ...)] escreve o resultado em um formato específico.
A classe [System] dá acesso a dois fluxos de escrita, seus campos estáticos [out] e [err], do tipo [PrintStream]:
- [System.out.println()] escreve no fluxo [out], a saída padrão, que normalmente está associada à tela;
- [System.err.println()] escreve no fluxo [err], a saída de erro, que também normalmente está associada à tela.
A classe [IO] (Java 25) fornece os métodos [println] e [print], que escrevem em [System.out]. Os fluxos [out] e [err] podem ser redirecionados para arquivos em tempo de execução, como veremos em breve.
3.4.2. Leitura de dados digitados no teclado
O fluxo de dados do teclado é identificado pelo campo [System.in], do tipo [InputStream]. É um fluxo de bytes, pouco conveniente para uso direto. Durante muito tempo, para ler uma linha de texto, era necessário envolvê-lo em outros objetos:
ou usar a classe [Scanner] (Java 5). A partir do Java 25, a classe [IO] fornece um método muito mais simples, [readln], em duas formas:
A linha digitada no teclado, sem o caractere de fim de linha, é armazenada na variável [line] e pode então ser processada pelo programa. A segunda forma exibe primeiro um prompt, sem passar para a linha seguinte. Como vimos, [readln] retorna [null] quando o fluxo de entrada se esgota. O fluxo [System.in] pode ser redirecionado para um arquivo, assim como os fluxos [out] e [err]. Por fim, observe a classe [Console], obtida a partir de [System.console()], cujo método [readPassword] lê uma senha sem exibi-la.
3.4.3. Exemplo de entrada/saída
O programa [Basics09.java] ilustra operações de entrada/saída pelo teclado e pela tela:
Resultados:
Comentários:
- Linha 4: [obj] é uma referência a objeto;
- Linha 5: [obj] é exibido na tela. O método [obj.toString()] é chamado para obter o texto a exibir;
- linha 9: dados são escritos no fluxo [err];
- linha 10: o mesmo, mas com um formato. O primeiro parâmetro, "i=%d%n," é o formato de exibição; os demais parâmetros são os valores a exibir: %d é substituído pelo valor de [i], e %n pelo caractere de fim de linha do sistema (\r\n no Windows e \n no Linux e no macOS);
- linha 13: um prompt é exibido sem passar para a linha seguinte e, em seguida, a linha digitada no teclado é lida;
- linha 14: se [line] fosse igual a [null], a concatenação produziria a string "null".
Nos resultados:
- linha 2: a saída gerada pela linha 5 do código. O método [toString()] da classe [Object] retorna o nome completo da classe do objeto, seguido do caractere @ e de um código numérico hexadecimal (seu “hash code”), que pode variar de uma execução ou máquina para outra. As classes geralmente sobrescrevem esse método para exibir algo mais útil, como faremos no Capítulo 4;
- linhas 3–4: as duas escritas no fluxo [err] aparecem na tela exatamente como as do fluxo [out].
3.4.4. Redirecionamento de entrada/saída
Windows, Linux e macOS reconhecem três dispositivos padrão:
- o dispositivo de entrada padrão, que por padrão se refere ao teclado e é numerado 0;
- o dispositivo de saída padrão, que por padrão se refere à tela e é numerado 1;
- o dispositivo de erro padrão, que por padrão se refere à tela e é numerado 2.
Em Java, o fluxo de escrita [System.out] escreve no dispositivo 1, o fluxo de escrita [System.err] escreve no dispositivo 2 e o fluxo de leitura [System.in] lê dados do dispositivo 0.
Ao executar um programa em uma janela de comandos, é possível especificar quais dispositivos serão 0, 1 e 2 para o programa em execução. Depois dos argumentos do programa, você pode redirecionar os dispositivos de entrada e saída padrão para arquivos:
Redirecionamento | Significado |
0<in.txt ou <in.txt | O fluxo de entrada padrão nº 0 é redirecionado para o arquivo in.txt. No programa, o fluxo [System.in] lerá, portanto, seus dados do arquivo in.txt |
1>out.txt ou >out.txt | redireciona a saída nº 1 para o arquivo out.txt. No programa, o fluxo [System.out] escreverá, portanto, seus dados no arquivo out.txt |
1>>out.txt ou >>out.txt | Igual ao anterior, mas os dados escritos são acrescentados ao conteúdo atual do arquivo out.txt |
2>err.txt | redireciona a saída nº 2 para o arquivo err.txt. No programa, o fluxo [System.err] escreverá, portanto, seus dados no arquivo err.txt |
2>>err.txt | Igual ao anterior, mas os dados escritos são acrescentados ao conteúdo atual do arquivo err.txt |
1>out.txt 2>err.txt | Os dispositivos 1 e 2 são ambos redirecionados para arquivos |
Observe que, para redirecionar os fluxos de entrada/saída de um programa para arquivos, não é necessário modificá-lo: o sistema operacional determina a natureza dos dispositivos 0, 1 e 2. Considere o seguinte programa, [Basics10.java]:
Os redirecionamentos se aplicam ao programa iniciado pelo comando [java]. Eis uma sessão em um terminal Linux (bash):
Comentários:
- linha 1: colocamos a string "test" no arquivo in.txt;
- linha 2: o conteúdo do arquivo in.txt é exibido para verificação;
- linha 4: execução do programa. O fluxo [System.in] é redirecionado para o arquivo in.txt, o fluxo [System.out] para o arquivo out.txt e o fluxo [System.err] para o arquivo err.txt. A execução não produz nenhuma saída;
- linhas 5–6: o conteúdo do arquivo out.txt mostra que o arquivo in.txt foi lido e que a escrita no fluxo [out] foi redirecionada para out.txt;
- linhas 7–8: verificação semelhante para o arquivo err.txt;
- linhas 9–10: somente o fluxo [err] é redirecionado: a tela exibe apenas a operação de escrita no fluxo [out];
- linhas 11–12: somente o fluxo [out] é redirecionado: a tela exibe apenas a operação de escrita no fluxo [err].
Fica claro que os fluxos [out] e [err] não escrevem nos mesmos dispositivos, já que podem ser redirecionados separadamente. O fluxo [err] destina-se às mensagens de erro: isso permite redirecionar a saída de um programa para um arquivo e, ainda assim, ver suas mensagens de erro na tela.
Os operadores >, >> e 2> são escritos da mesma forma no prompt de comando do Windows ([cmd]), no PowerShell e no bash. O operador < é reconhecido pelo [cmd] e pelo bash, mas não pelo PowerShell, que o reserva para uso futuro: no PowerShell, usa-se um pipe (|) para enviar um arquivo à entrada padrão de um programa. Os comandos a seguir, fornecidos a título ilustrativo (não foram executados para este curso), fazem no Windows o que a sessão bash acima faz:
3.4.5. Atribuição do valor de uma expressão a uma variável
Aqui nos interessamos pela operação [variable = expression;]. A expressão pode ser aritmética, relacional, booleana, de string etc.
3.4.5.1. Interpretação da operação de atribuição
A operação [variable = expression;] é, ela própria, uma expressão avaliada da seguinte forma:
- o lado direito da atribuição é avaliado: o resultado é um valor V;
- o valor V é atribuído à variável;
- o valor V é também o valor da atribuição, desta vez vista como uma expressão.
É por isso que a operação [V1 = V2 = expression] é válida. Como o operador = é avaliado da direita para a esquerda, obtemos [V1 = (V2 = expression)]. A expressão [V2 = expression] é avaliada e tem o valor V. Sua avaliação fez com que V fosse atribuído a V2. O operador = seguinte é então avaliado como [V1 = V]. O valor dessa expressão continua sendo V; sua avaliação resulta na atribuição de V a V1. Assim, a operação [V1 = V2 = expression] é uma expressão cuja avaliação:
- faz com que o valor de [expression] seja atribuído às variáveis V1 e V2;
- retorna o valor de [expression].
Isso pode ser generalizado para uma expressão da forma [V1 = V2 = ... = Vn = expression].
3.4.5.2. Expressões aritméticas
Os operadores usados em expressões aritméticas são os seguintes:
Operador | Função |
+ | adição |
- | subtração |
* | multiplicação |
/ | divisão: o resultado é o quociente exato se pelo menos um dos operandos for um número real. Se ambos os operandos forem inteiros, o resultado é o quociente inteiro. Assim, 5/2 é igual a 2 e 5.0/2 é igual a 2.5 |
% | resto da divisão (módulo), independentemente da natureza dos operandos. O resto tem o mesmo sinal que o dividendo: -5 % 2 é igual a -1. O método [Math.floorMod(-5, 2)] retorna o resto no sentido matemático, com o mesmo sinal que o divisor: 1 |
Há várias funções matemáticas. Eis algumas:
Função | Função desempenhada |
[double sqrt(double x)] | raiz quadrada |
[double cos(double x)], [sin], [tan] | cosseno, seno, tangente (ângulo em radianos) |
[double pow(double x, double y)] | x elevado à potência y |
[double exp(double x)] | exponencial |
[double log(double x)], [log10] | logaritmo natural, decimal |
[abs(x)], [max(x, y)], [min(x, y)] | valor absoluto, máximo, mínimo (para os tipos int, long, float e double) |
[double floor(double x)], [ceil] | parte inteira inferior, parte inteira superior |
[long round(double x)], [double rint(double x)] | arredondado para o inteiro mais próximo |
[clamp(value, min, max)] | valor limitado ao intervalo [min, max] (Java 21) |
[Math.PI], [Math.E] | as constantes π e e |
Todas essas funções são métodos estáticos de uma classe Java chamada [Math] (pacote [java.lang]). Ao usá-las, é preciso prefixá-las com o nome da classe em que são definidas. Assim, escreveríamos:
A descrição completa da classe [Math] pode ser encontrada na documentação online do Java, docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/Math.html.
Os números reais do tipo [double] são codificados em binário: a maioria dos números decimais, como 0.1, tem apenas um valor aproximado nessa representação. Isso não tem importância para cálculos científicos, mas é inaceitável para valores monetários. A classe [BigDecimal] (no pacote [java.math]), por sua vez, representa um número decimal com exatidão, com quantos dígitos forem necessários. Como Java não permite redefinir operadores, os cálculos são feitos por meio de métodos: [add], [subtract], [multiply], [divide], [compareTo]... Um [BigDecimal] é imutável: uma operação não modifica o objeto ao qual é aplicada; em vez disso, retorna um novo objeto.
O programa [Basics11.java] é o seguinte:
Resultados:
Comentários:
- linha 4: a divisão de dois inteiros é uma divisão inteira. Nesta concatenação, as divisões são realizadas antes dos operadores + porque o operador / tem precedência maior (veja abaixo);
- linha 6: o resto tem o mesmo sinal que o dividendo; o operador % também se aplica a números reais;
- linha 7: [Math.floorMod] retorna um resto com o mesmo sinal que o divisor;
- linha 10: dividir um número real por zero não causa erro; retorna infinito ([Infinity]) ou o valor especial [NaN] (“Not a Number”) para 0/0;
- linhas 12–17: no entanto, dividir um inteiro por zero lança uma exceção [ArithmeticException];
- Linhas 20–21: o exemplo acima. [Math.sqrt] é convertido em [double]: 2.0;
- linha 27: [floor] arredonda para baixo, [ceil] arredonda para cima. Para truncar um número real em direção a zero, ele é convertido em inteiro, como veremos mais adiante;
- linha 29: [Math.round] arredonda para o inteiro mais próximo; um valor exatamente no meio entre dois inteiros é arredondado para cima: 2.5 torna-se 3 e -2.5 torna-se -2. O resultado é um [long];
- linha 31: [Math.rint] arredonda um valor situado exatamente no meio para o inteiro par mais próximo (arredondamento “bancário”): 2.5 torna-se 2 e 3.5 torna-se 4. O resultado é um [double];
- linha 33: [Math.clamp] (Java 21) traz 150 de volta para o intervalo [0, 100];
- linha 36: precedência dos operadores, conforme mostrado abaixo;
- linha 37: "x" + 1 + 2 é avaliado da esquerda para a direita: "x" + 1 produz a string "x1," à qual 2 é concatenado. Para realizar primeiro a adição, é preciso escrever "x" + (1 + 2);
- linha 41: uma atribuição múltipla;
- linha 45: 0.1 e 0.2 não têm representações binárias exatas: sua soma não é exatamente 0.3;
- linha 47: dois objetos [BigDecimal] criados a partir de strings. Não escreva [new BigDecimal(0.1)]: o parâmetro seria o [double] 0.1, cujo valor exato é 0.1000000000000000055511151231257827021181583404541015625. [BigDecimal.valueOf(0.1)], que usa a string "0.1", funciona, porém;
- linha 48: a adição exata;
- linhas 49–51: [BigDecimal.valueOf(3)] converte um inteiro. Um produto tem tantas casas decimais quanto a soma das casas de seus dois fatores: 59.97 × 1.2 = 71.964;
- linha 53: [setScale(2, RoundingMode.HALF_UP)] arredonda para duas casas decimais, com os valores situados exatamente no meio entre dois dígitos arredondados para longe de zero: é o arredondamento comercial;
- linha 55: 10/3 não tem representação decimal finita. O método [divide] exige, portanto, uma precisão, dada aqui por [MathContext.DECIMAL64] (16 dígitos significativos). Sem ela, a divisão resultaria em [ArithmeticException]: [Non-terminating decimal expansion; no exact representable decimal result.]
3.4.5.3. Ordem de avaliação das expressões aritméticas
A ordem de precedência dos operadores na avaliação de uma expressão aritmética é a seguinte (da mais alta para a mais baixa):
Os operadores dentro de um mesmo bloco [ ] têm a mesma prioridade. Quando as prioridades são iguais, a avaliação prossegue da esquerda para a direita: 10 - 4 - 3 é avaliado como (10 - 4) - 3 = 3.
3.4.5.4. Expressões relacionais
Os operadores são os seguintes: <, <=, ==, !=, >, >=. Sua precedência é:
- >, >=, <, <=;
- ==, !=.
O resultado de uma expressão relacional é o booleano [false] se a expressão for falsa e [true] caso contrário.
Comparação de dois caracteres
Sejam C1 e C2 dois caracteres. Eles podem ser comparados com os operadores <, <=, ==, !=, >, >=. São comparados seus códigos Unicode, que são números. Segundo a ordem Unicode, valem as seguintes relações:
Comparação de duas strings
Elas são comparadas caractere por caractere. A primeira desigualdade encontrada entre dois caracteres resulta em uma desigualdade de mesmo sentido para as strings. Considere a comparação das strings "Cart" e "Cat":
Essa última desigualdade permite concluir que "Cart" < "Cat." Considere a comparação das strings "Cat" e "Catkin." Elas são iguais até que a string "Cat" se esgote. Nesse caso, a string esgotada é declarada a "menor". Temos, portanto, a relação "Cat" < "Catkin."
Métodos para comparar duas strings
Atenção: esta é uma armadilha clássica do Java. Quando aplicados a duas strings—ou a quaisquer dois objetos—os operadores == e != comparam referências, não conteúdos. [s1 == s2] é verdadeiro se as duas variáveis se referem ao mesmo objeto na memória, não se as duas strings contêm os mesmos caracteres. Para testar se duas strings são iguais, use o método [equals] da classe [String], ou [equalsIgnoreCase] para ignorar diferenças entre maiúsculas e minúsculas. Os operadores <, <=, > e >= não se aplicam a strings: é preciso usar o método [compareTo] (ou [compareToIgnoreCase]). Ele retorna um inteiro:
- zero se as duas strings forem iguais;
- positivo se a string nº 1 for maior que a string nº 2;
- negativo se a string nº 1 for menor que a string nº 2.
[compareTo] compara os códigos Unicode caractere por caractere: o resultado é a diferença entre os códigos dos dois primeiros caracteres diferentes ou a diferença de comprimento se uma das strings for o início da outra. Isso não é ordem de dicionário: como o código de 'é' (233) é maior que o de 'f' (102), "élan" vem depois de "face." Para ordenar textos destinados a usuários, use o objeto [Collator] (pacote [java.text]), que aplica as regras de ordenação de um idioma específico. [compareTo] continua sendo o método correto para identificadores, palavras-chave e nomes de arquivos.
O programa [Basics12.java] é o seguinte:
Resultados:
Comentários:
- linha 4: uma expressão relacional;
- linhas 8–9: comparação de caracteres;
- linha 10: a conversão [(int)] de um caractere retorna seu código Unicode;
- linha 14: a variável [n] recebe um inteiro negativo, pois "cat" < "dog": a diferença entre os códigos de 'c' (99) e 'd' (100);
- linha 15: a variável [equal] tem o valor [true] se as duas strings forem iguais e [false] caso contrário;
- linha 17: a string que se esgota primeiro é a mais curta; o resultado é a diferença de comprimentos: 3 - 6. Em um literal de string, \" denota aspas;
- linha 20: o método [concat] constrói, em tempo de execução, um novo objeto string que contém "cat";
- linhas 21–22: [string1] e [string3] têm o mesmo conteúdo, mas se referem a dois objetos diferentes: == retorna [false], [equals] retorna [true]. A armadilha é ainda mais insidiosa porque dois literais de string idênticos são armazenados apenas uma vez na memória, de modo que ["cat" == "cat"] é verdadeiro: um teste com == pode parecer funcionar durante os testes. Usaremos sempre [equals];
- linha 25: 233 - 102 = 131: para [compareTo], “élan” vem depois de “face”;
- linha 26: 'C' (67) - 'c' (99) = -32;
- linhas 28–30: ignorando a diferença entre maiúsculas e minúsculas, “Cat” e “cat” são iguais;
- linhas 32–34: um [Collator] para o francês: “élan” precede “face” e “Cat” vem depois de “cat” (quando as letras são as mesmas, a minúscula vem antes da maiúscula). O método [compare] retorna um inteiro negativo, zero ou positivo, assim como [compareTo].
3.4.5.5. Expressões booleanas
Os operadores que podem ser usados são AND (&&), OR (||) e NOT (!). O resultado de uma expressão booleana é um valor booleano. Precedência dos operadores:
- ! ;
- && ;
- ||.
Os operadores relacionais têm precedência sobre os operadores && e ||. Esses dois operadores avaliam seu operando da direita somente se necessário: em [a && b], b não é avaliado se a for falso; em [a || b], b não é avaliado se a for verdadeiro. Isso é chamado de “avaliação em curto-circuito”. Portanto, é seguro escrever [text != null && text.length() > 0]. Os operadores & e |, quando aplicados a dois booleanos, realizam o mesmo cálculo, mas sempre avaliam os dois operandos.
3.4.5.6. Operações bit a bit
Sejam [i] e [j] dois inteiros:
Operação | Função |
i << n | Desloca i n bits para a esquerda. Os bits que entram são zeros |
i >> n | Desloca i n bits para a direita. O bit de sinal é preservado |
i >>> n | deslocamento à direita sem sinal: os bits que entram são zeros, mesmo que i seja negativo |
i & j | realiza o AND lógico bit a bit de i e j |
i|j | realiza o OR lógico bit a bit de i e j |
~i | complementa i a 1 |
i ^ j | realiza a operação OU EXCLUSIVO entre i e j bit a bit |
O programa [Basics13.java] é o seguinte:
Resultados:
Comentários:
- Linha 3: dois inteiros [short];
- linha 5: o valor 0xF123 (61731) não cabe em um [short], cujo máximo é 32767. O tipo [char], um inteiro sem sinal de 16 bits, consegue armazená-lo;
- linha 6: o especificador %04x exibe um inteiro hexadecimal (x) de 4 dígitos, preenchido com zeros (04). Aplicado a um [short], mostra seus 16 bits: -13 torna-se fff3. O especificador %x não aceita um [char]: ele é convertido em [int];
- linha 7: as operações sobre [short] ou [char] são realizadas sobre [int]: os operandos são primeiro convertidos em [int] (isso se chama promoção), e o resultado é um [int];
- linha 9: os resultados são então convertidos de volta em [short] para exibir 4 dígitos hexadecimais. Sem a conversão, ~i seria exibido com 8 dígitos (ffffff9b);
- linha 12: o método [binary] (linhas 19–25) exibe os n bits menos significativos de um inteiro. Verificamos o AND lógico de i e j bit a bit;
- linha 15: o deslocamento [>>] preserva o bit de sinal de m, que é negativo; o deslocamento [>>>] preenche com zeros;
- linha 22: [(value >>> rank) & 1] move o bit nº [rank] para a posição 0 e depois o isola dos demais. A classe [StringBuilder], apresentada no Capítulo 5, constrói uma string por adições sucessivas.
3.4.5.7. Combinação de operadores
[a = a + b] pode ser escrito como [a += b]; [a = a - b] pode ser escrito como [a -= b]. O mesmo vale para os operadores /, %, *, <<, >>, >>>, &, |, ^. Assim, [a = a / 2;] pode ser escrito como [a /= 2;]. Uma pequena diferença: o operador combinado inclui uma conversão implícita para o tipo da variável. Se [s] for um [short], [s = s + 1;] é rejeitado (o resultado da adição é um [int]), ao passo que [s += 1;] é aceito.
3.4.5.8. Operadores de incremento e decremento
A notação [variable++] significa [variable = variable + 1] ou [variable += 1]. A notação [variable--] significa [variable = variable - 1] ou [variable -= 1]. Quando usados em uma expressão, esses operadores têm duas formas:
- [i++] (pós-fixado): o valor da expressão é o valor de i antes do incremento;
- [++i] (pré-fixado): o valor da expressão é o valor de i depois do incremento.
3.4.5.9. O operador ternário ?
A expressão [expr_cond ? expr1 : expr2] é avaliada da seguinte forma:
- A expressão [expr_cond] é avaliada. É uma expressão booleana;
- se for verdadeira, o valor da expressão é o de [expr1], e [expr2] não é avaliada;
- se for falsa, ocorre o contrário: o valor da expressão é o de [expr2], e [expr1] não é avaliada.
A operação [i = (j > 4 ? j + 1 : j - 1);] atribuirá o valor j+1 à variável i se j > 4 e j-1 caso contrário. É o mesmo que escrever [if (j > 4) i = j + 1; else i = j - 1;], mas é mais conciso.
3.4.5.10. Valores nulos: sem operadores especializados
Ao contrário de outras linguagens como C# ou Kotlin, Java não possui operadores dedicados ao valor [null] (valor de substituição, acesso condicional a um membro). Em vez disso, usamos:
- o operador ternário, [a != null ? a : b], ou o método [Objects.requireNonNullElse(a, b)] (Java 9), que retorna a se não for igual a [null]e b caso contrário. Ele serve para atribuir um valor de reserva: [String name = Objects.requireNonNullElse(IO.readln(), "");];
- um teste simples, [if (a == null) a = b;], para atribuir um valor a uma variável somente se ela for igual a [null];
- a classe
*[Optional]e seu método*[map]para acessar um membro somente se o objeto existir: [Optional.ofNullable(text).map(String::length)] retorna um [Optional] vazio se [text] for igual a [null]e um [Optional] contendo o comprimento do texto caso contrário.
O programa [Basics14.java] combina esses vários operadores:
Resultados:
Comentários:
- linha 5: uma expressão booleana;
- linhas 9–19: operadores combinados: 10+5=15, 15*2=30, 30/4=7 (divisão inteira), 7%4=3, 3<<2=12;
- linha 23: [j] recebe 5 e, em seguida, [i] é definido como 6;
- linha 24: [i] passa para 7 e, em seguida, [k] recebe 7;
- linhas 31–32: dois operadores ternários;
- linha 37: [input] é igual a [null]: [name] recebe "unknown";
- linha 39: o operador ternário permite passar de um [Integer] para um [int] sem risco de exceção: [age] só é desempacotado se não for igual a [null];
- linhas 43–45: a atribuição ocorre somente se [title] for igual a [null];
- linha 49: [text] é igual a [null]: [Optional.ofNullable(text)] está vazio, e [map] retorna um [Optional] vazio sem chamar [length()]. A notação [String::length] é uma referência a método: ela se refere ao método [length] da classe [String]. Examinaremos isso no Capítulo 7;
- linha 50: se [length] estiver vazio, a string "null" é exibida;
- linha 52: [text] é "hello": [map] aplica [length()], e o resultado é 5.
3.4.5.11. Precedência geral dos operadores
A tabela a seguir lista a precedência dos operadores, da mais alta para a mais baixa:
Operadores | Associatividade |
[x.y] [f(x)] [a[i]] [x++] [x--] [new] | lr |
[+x] [-x] [!x] [~x] [++x] [--x] [(T)x] (mudança de tipo) | rl |
[*] [/] [%] | lr |
[+] [-] | lr |
[<<] [>>] [>>>] | lr |
[<] [<=] [>] [>=] [instanceof] | lr |
[==] [!=] | lr |
[&] | lr |
[^] | lr |
[|] | lr |
[&&] | lr |
[||] | lr |
[? :] (ternário) | rl |
[=] [+=] [-=] etc., [->] (lambda) | rl |
lr indica que, quando os operadores têm a mesma precedência, observa-se a precedência da esquerda para a direita: quando uma expressão contém operadores de mesma precedência, o operador mais à esquerda é avaliado primeiro. rl indica precedência da direita para a esquerda. Em caso de dúvida, não hesite em usar parênteses: eles também tornam a expressão mais legível.
3.4.5.12. Conversão de tipo (cast)
É possível, dentro de uma expressão, alterar temporariamente a representação de um valor. Isso se chama conversão de tipo (cast). A sintaxe para alterar o tipo de um valor em uma expressão é a seguinte:
O valor passa então a ter o tipo especificado. Isso resulta em uma mudança na representação do valor. Distinguimos:
- As conversões "de ampliação" (widening), realizadas automaticamente pelo compilador: [byte] para [short], [short] para [int], [char] para [int], [int] para [long], [long] para [float] ou [double], [float] para [double]... Elas mantêm a ordem de grandeza do valor. As que vão de um [int] para um [float], ou de um [long] para um [float] ou um [double], podem, no entanto, perder precisão: um [float] tem apenas 7 dígitos significativos, enquanto um [double] tem de 15 a 16;
- as conversões "de redução" (narrowing), que podem resultar em perda de informação e devem ser solicitadas explicitamente pelo programador com a notação (tipo): de um [double] para um [int] (a parte decimal é perdida), de um [long] para um [int] (os bits mais significativos são perdidos) etc.
Um estouro (overflow) em um cálculo com inteiros ou em uma conversão entre inteiros nunca é sinalizado: o resultado simplesmente fica incorreto. Java não tem uma palavra-chave para solicitar uma verificação. Quando esse risco existe, use os métodos [addExact], [subtractExact], [multiplyExact], [incrementExact], [toIntExact]... da classe [Math] (Java 8), que lançam uma exceção [ArithmeticException] se o limite for excedido.
O programa [Basics15.java] é o seguinte:
Resultados:
Comentários:
- Linha 4: [f1] terá o valor 0.0. A divisão 3/4 é uma divisão inteira, pois ambos os operandos são do tipo [int]; seu resultado, 0, é então convertido em [float];
- Linha 5: [(float) i] é o valor de [i] convertido em [float]. Temos agora uma divisão entre um número real do tipo [float] e um inteiro do tipo [int]: o valor de [j] também é transformado em [float], e então os dois números reais são divididos. [f2] tem o valor 0.75. Na operação [(float) i], [i] é um valor codificado exatamente em 4 bytes, enquanto [(float) i] é o mesmo valor codificado de forma aproximada como número real em 4 bytes. Essa transcodificação ocorre apenas durante o cálculo: a variável [i] mantém sempre o tipo [int];
- linhas 9–10: conversões de ampliação;
- linha 15: converter um número real em inteiro trunca a parte decimal (em direção a zero);
- Linha 16: para arredondar o número, usamos [Math.round], que resulta em um [long], e depois o convertemos em [int];
- linha 18: o sufixo L é essencial: 3 bilhões excedem a faixa de um [int];
- linha 19: 3 bilhões não cabem em um [int]: apenas os 32 bits menos significativos são mantidos, e o resultado deixa de fazer sentido;
- linha 22: um número real grande demais para um [int] é reduzido a [Integer.MAX_VALUE]; o valor [NaN] torna-se 0;
- linhas 25–26: conversões entre caracteres e códigos Unicode; a segunda é implícita;
- linha 31: o estouro de capacidade passa despercebido: obtém-se o menor valor de [int];
- linha 35: com [Math.addExact], o estouro dispara uma exceção [ArithmeticException];
- linha 41: [Math.toIntExact] converte um [long] em [int] e também lança uma exceção se o valor não couber em um [int].
Mesmo quando o estouro ocorre em uma expressão formada apenas por constantes, como [Integer.MAX_VALUE + 1], o compilador a aceita sem aviso: ele mesmo calcula o valor, -2147483648.
3.5. Instruções de controle do fluxo do programa
3.5.1. Parada
O método [exit] da classe [System] permite interromper a execução do programa:
[exit] encerra o processo atual e devolve o controle ao processo chamador, normalmente o interpretador de comandos. O valor de [status], conhecido como código de retorno, pode ser usado pelo interpretador de comandos. Por convenção, 0 indica que o programa foi executado com sucesso, enquanto qualquer outro valor sinaliza um erro. No Windows, o código de retorno está disponível na variável [%ERRORLEVEL%] no prompt de comando e na variável [$LASTEXITCODE] no PowerShell; no Linux e no macOS, na variável [$?] do shell. Assim, [System.exit(0);] encerrará a execução do programa com o código de retorno 0.
Sem uma chamada a [System.exit], um programa termina com o código de retorno 0 quando seu método [main] termina, eventualmente com uma instrução [return]. Se for encerrado por uma exceção que ninguém capturou, ele exibe essa exceção e termina com o código de retorno 1. Em Java, o método [main] não pode retornar um inteiro: [System.exit] é a única maneira de especificar o código de retorno.
O programa [Basics16.java] recebe seu código de retorno como argumento:
Resultados em um terminal bash:
Comentários:
- linha 2: o método [main] recebe os argumentos da linha de comando no array [args]. Os argumentos do programa são descritos mais adiante;
- linha 8: se houver pelo menos um argumento, o primeiro é convertido em inteiro; caso contrário, converte-se a string vazia, o que falha. Assim, a ausência de argumento e um argumento não numérico são tratados pela mesma cláusula [catch];
- linha 11: o programa termina com o código de retorno 1;
- linha 12: esta instrução nunca será executada, mas o compilador não sabe que [System.exit] nunca devolve o controle. Sem ela, o compilador assumiria que a linha 14 poderia ser alcançada com a variável [code] não inicializada e rejeitaria o programa: [error: variable code might not have been initialized];
- linha 15: saída com o código de retorno passado como argumento. A linha seguinte não é executada;
- Linhas 4–5 e 9–10 dos resultados: o comando [echo $?] exibe o código de retorno do último programa executado: 3 e depois 1.
3.5.2. Estrutura de decisão simples
Notas:
- A condição é colocada entre parênteses. Ela deve ser do tipo [boolean]: ao contrário da linguagem C, Java rejeita [if (n)] quando [n] é um inteiro;
- cada ação termina com ponto e vírgula;
- as chaves não são seguidas de ponto e vírgula;
- as chaves só são obrigatórias se houver mais de uma ação; no entanto, costuma-se usá-las mesmo para uma única ação, por legibilidade e para evitar erros ao acrescentar uma ação. Em Java, é costume colocar a chave de abertura no fim da linha;
- a cláusula [else] pode ser omitida;
- não existe a palavra-chave [then].
O equivalente algorítmico dessa estrutura é a estrutura se...então...senão:
Exemplo:
As estruturas de escolha podem ser aninhadas. Isso às vezes leva ao problema ilustrado pelo programa [Basics17.java]:
Resultados:
Comentários:
- Linhas 5–9: a qual [if] se refere o [else] da linha 8? A regra é que um [else] sempre se refere ao [if] mais próximo: [if (n > 6)], linha 6. A indentação do código, que não tem efeito sobre o compilador, foi escolhida para ilustrar isso;
- linhas 13–19: aqui, queríamos colocar um [else] junto a [if (n2 > 1)], e não um [else] junto a [if (n2 > 6)]. Por causa da regra anterior, somos obrigados a colocar [if (n2 > 1) { ... }] entre chaves;
- Linhas 24–32: uma sequência de escolhas mutuamente exclusivas é escrita com instruções [else if] sucessivas. As condições são testadas em ordem; a primeira que for avaliada como verdadeira determina a ação a ser executada. O compilador verifica que a variável [honours], declarada sem valor na linha 23, recebe um valor em todos os ramos antes de ser usada na linha 33.
3.5.3. Estrutura de casos
3.5.3.1. A instrução switch
A sintaxe histórica é a seguinte:
Notas:
- O valor da expressão de controle do [switch] pode ser um inteiro ([int], [short], [byte], [char] ou suas classes wrapper), uma string (Java 7), um valor de enum e, desde o Java 21, qualquer objeto (veja a filtragem por padrão adiante). Os tipos [long], [float], [double], e [boolean] não são aceitos;
- a expressão de controle é colocada entre parênteses;
- a cláusula [default] pode ser omitida;
- os valores vi são valores possíveis da expressão. Se a expressão for avaliada como vi, as ações que seguem a cláusula [case vi] são executadas. A partir do Java 14, uma cláusula pode listar vários valores: [case "saturday", "sunday":];
- A instrução [break] sai da estrutura de casos. Atenção: se ela for omitida, a execução continua com as ações da cláusula [case] seguinte (“fall-through”). O compilador aceita isso; com a opção [-Xlint:all], ele emite apenas o aviso [warning: [fallthrough] possible fall-through into case]. Essa omissão é um erro comum, que a forma com seta apresentada a seguir impede.
Exemplo em algoritmos:
3.5.3.2. A forma com seta e a expressão switch
O Java 14 introduziu uma segunda forma da cláusula, [case v1, v2 -> action], em que a seta é seguida de uma única instrução ou de um bloco entre chaves. Somente a ação da cláusula selecionada é executada: não há necessidade de escrever um [break], nem há encadeamento de uma cláusula com a seguinte.
Muito frequentemente, uma estrutura de casos é usada apenas para selecionar um valor. Nesse caso, [switch] pode ser usado como uma expressão (Java 14):
A expressão switch deve ser exaustiva: ela deve fornecer um valor para todos os valores possíveis da expressão de controle, o que geralmente exige uma cláusula [default]. Quando uma cláusula requer várias instruções, escreve-se um bloco, que retorna seu valor por meio da instrução [yield].
Desde o Java 21, uma cláusula [case] pode conter um padrão em vez de uma constante. Um padrão de tipo, [case Integer i], corresponde se o objeto examinado for do tipo [Integer]; o objeto fica então disponível, com esse tipo, na variável [i]. Um guard [when condition] acrescenta uma condição: [case Integer i when i > 0] só é selecionado para um inteiro positivo. Uma cláusula [case null] processa o valor [null], que de outra forma provocaria uma [NullPointerException]. As cláusulas são avaliadas em ordem: a primeira que corresponde é selecionada. A mesma filtragem se aplica ao operador [instanceof] (Java 16): [if (o instanceof String s && s.length() > 3)].
O Java 25 ainda não permite escrever tais padrões para tipos primitivos ([case int i when i > 0]): esse recurso está disponível em uma versão de prévia, que não usaremos. Para classificar um [int] com guards, aplicamos o [switch] a um [Integer].
O programa [Basics18.java] é o seguinte:
Resultados:
Comentários:
- linhas 5–17: a implementação em Java do algoritmo acima;
- linha 7: [return] encerra o método [main] e, portanto, o programa;
- linha 23: dois valores para as mesmas ações. Antes do Java 14, teríamos escrito duas cláusulas sucessivas, [case "saturday":] e [case "sunday":], com a primeira—que está vazia—“caindo” na segunda;
- linhas 31–34: a mesma estrutura de casos com setas; sem mais [break];
- linhas 37–41: uma expressão
switchsobre uma string. Ela termina com ponto e vírgula, como qualquer instrução de atribuição. A cláusula*[default]* a torna exaustiva; - linhas 44–51: uma cláusula cuja ação é um bloco: a instrução [yield] (linha 49) avalia a expressão;
- linhas 76–84: o método [classify]. Seu parâmetro [Integer] recebe os inteiros -5, 0, 7… empacotados automaticamente (linhas 55–59). Os guards [when] classificam o inteiro, e a constante 0 é incluída nos padrões. A cláusula [default] trata os valores restantes, neste caso os inteiros maiores ou iguais a 100;
- linha 61: um array de objetos de tipos diferentes: os números 12, -3 e 2.5 são empacotados em [Integer] e [Double];
- linhas 86–94: o método [describe] seleciona com base no tipo do objeto. Na linha 91, a variável [s] é do tipo [String]: seu método [length()] pode ser chamado sem conversão. A cláusula sem guard, [case Integer i] (linha 90), deve ser colocada depois da cláusula com guard (linha 89), que ela esconderia caso contrário: o compilador rejeitaria o programa;
- Linhas 68–74: dois métodos chamados pelo primeiro, [switch].
3.5.4. Estruturas de repetição
3.5.4.1. Número conhecido de repetições
Estrutura "for"
A sintaxe é a seguinte:
Notas:
- Os três argumentos do [for] são colocados entre parênteses e separados por ponto e vírgula;
- Cada ação do [for] termina com ponto e vírgula;
- as chaves só são obrigatórias se houver mais de uma ação;
- a chave não é seguida de ponto e vírgula.
O equivalente algorítmico é a estrutura para:
que pode ser traduzida em uma estrutura while:
Estrutura for-each
A sintaxe é a seguinte:
Notas:
- [collection] é um array ou uma coleção iterável de objetos (que implementa a interface [Iterable]). Veremos as coleções ([List], [Set], [Map]...) no Capítulo 5;
- [Type] é o tipo dos elementos da coleção. Para um array, é o tipo dos elementos do array. Pode-se escrever [var] no lugar;
- [variable] é uma variável local do laço que assumirá sucessivamente todos os valores da coleção. Atribuir-lhe outro valor dentro do laço não modifica a coleção; você pode declará-la como [final] para impedir isso.
3.5.4.2. Número desconhecido de iterações
Laço while
O laço continua enquanto a condição for verdadeira. O laço pode nunca ser executado. As notas são as mesmas do [for]. A estrutura algorítmica correspondente é a estrutura enquanto:
Laço "do while"
A sintaxe é a seguinte:
O laço continua até que a condição se torne falsa. Aqui, o laço é executado pelo menos uma vez. A estrutura algorítmica correspondente é a estrutura “repita … até”:
Estrutura geral de laço (for)
A sintaxe é a seguinte:
O laço continua enquanto a condição for verdadeira (avaliada antes de cada iteração). As instruções [start_instructions] são executadas antes de entrar no laço pela primeira vez. As instruções [end_of_loop_instructions] são executadas após cada iteração do laço. As várias instruções de [start_instructions] e de [end_of_loop_instructions] são separadas por vírgulas. A estrutura algorítmica correspondente é a seguinte:
3.5.4.3. Instruções de controle de laço
Instrução | Função |
[break] | Sai do laço [for], [while], [do ... while] |
[continue] | passa para a próxima iteração dos laços [for], [while], [do ... while] |
[break label] | sai do laço precedido pelo rótulo [label:], mesmo que a instrução esteja dentro de um laço aninhado |
[continue label] | passa para a próxima iteração do laço precedido pelo rótulo [label:] |
3.5.4.4. Exemplos
O programa [Basics19.java] é o seguinte:
Resultados:
Comentários:
- linhas 3–27: quatro maneiras de calcular a soma dos 10 primeiros inteiros;
- linhas 5–7: um [for] padrão;
- linhas 10–11: todo o trabalho é feito nas instruções de fim de laço; o corpo do laço está vazio. Java também aceita a sintaxe [for (...);], sem corpo, mas um ponto e vírgula colocado por engano depois de um [for] é um erro clássico e difícil de perceber. Um bloco vazio { } expressa a mesma coisa sem ambiguidade;
- linha 25: [i++] retorna o valor de [i] antes de ser incrementado: [i] é somado a [sum] e depois [i] é incrementado;
- linha 31: a forma mais comum de [for]: a variável do laço é declarada no [for] e existe apenas dentro do laço;
- linhas 38–40: o laço for-each percorre os elementos do array [friends];
- linhas 43–53: [continue] passa para a próxima iteração nos números pares; [break] encerra o laço assim que [k] ultrapassa 7;
- linhas 58–63: um laço infinito [while (true)], do qual se sai por meio de [break]. Essa forma é conveniente quando a condição de término é calculada no meio do laço. Vamos usá-la para a entrada de dados pelo teclado;
- linhas 67–76: busca do primeiro número negativo em um array bidimensional. O rótulo [search:] (linha 68) dá nome ao laço externo; a instrução [break search;] (linha 73) sai dos dois laços de uma só vez. Um simples [break] sairia apenas do laço interno. Java não possui uma instrução [goto] (a palavra-chave é reservada, mas não usada): os rótulos cumprem essa função neste caso específico.
3.6. Tratamento de exceções
Muitos métodos Java são capazes de lançar exceções, isto é, erros. Quando um método é capaz de lançar uma exceção, o programador deve tratá-la para criar programas mais tolerantes a erros: deve-se sempre evitar o encerramento abrupto de uma aplicação.
3.6.1. A estrutura try/catch/finally
O tratamento de exceções segue este esquema:
Se o código do bloco [try] não lançar uma exceção, a execução prossegue para a instrução seguinte; caso contrário, a execução prossegue para o corpo do bloco [catch] e depois para a instrução seguinte. Observe os seguintes pontos:
- [e] é um objeto do tipo [Exception] ou de um tipo derivado. Existem muitos tipos de exceções: [ArrayIndexOutOfBoundsException], [NumberFormatException], [ArithmeticException], [IllegalArgumentException], [NullPointerException], [IOException], etc. Ao escrever [catch (Exception e)], você indica que deseja tratar todos os tipos de exceções. Se o código da cláusula [try] puder gerar vários tipos de exceções, convém ser mais específico, tratando a exceção com várias cláusulas [catch]:
As cláusulas [catch] são avaliadas em ordem; a primeira cujo tipo corresponde à exceção é executada. Uma cláusula que trata um tipo de exceção específico deve, portanto, preceder uma que trata um tipo mais geral: o compilador rejeita uma cláusula que nunca poderia ser alcançada;
- uma cláusula [finally] pode ser acrescentada às cláusulas [try / catch]:
Ocorrendo ou não uma exceção, o código da cláusula [finally] é sempre executado. Essa cláusula era usada para fechar um arquivo; veremos que agora existe uma forma mais simples, o [try] com recursos;
- na cláusula [catch], pode ser que você não queira usar o objeto de exceção. No entanto, é preciso dar-lhe um nome: desde o Java 22, é possível escrever [catch (NumberFormatException _)], em que o caractere _ denota uma variável anônima que não será usada;
- A classe [Exception] possui um método, [getMessage()], que retorna a mensagem detalhando o erro ocorrido. Para exibi-la, escreva:
- O método [toString()] de uma exceção retorna o nome completo de sua classe seguido de sua mensagem; seu método [printStackTrace()] exibe também a pilha de chamadas—isto é, a lista de métodos que estavam em execução no momento do erro—juntamente com o nome do arquivo-fonte e o número da linha. Essa é a informação mais útil para o desenvolvedor, mas não se destina ao usuário. Neste curso, na maioria das vezes exibiremos o nome da classe da exceção—[ex.getClass().getName()] ou [ex.getClass().getSimpleName()]—e sua mensagem.
3.6.2. Um primeiro exemplo
O programa [Basics20.java] demonstra uma exceção gerada pelo uso de um elemento de array inexistente:
Resultados:
Comentários:
- linha 14: esta instrução lança uma exceção porque o array [tab] não possui um elemento de índice 100;
- linha 15: a cláusula [catch (Exception e)] captura todas as exceções;
- Linhas 16–17: a exceção é do tipo [java.lang.ArrayIndexOutOfBoundsException], e sua mensagem indica o índice incorreto e o tamanho do array (linha 10 dos resultados);
- linha 18: o programa sai do método [main] e, portanto, do programa;
- linhas 19–20: a cláusula [finally] foi executada (linha 11 dos resultados), embora a cláusula [catch] contivesse uma instrução [return]. Observe que a cláusula [finally] é sempre executada;
- linha 22: por causa do [return], esta linha não é executada.
3.6.3. Uma entrada validada
Eis outro exemplo, [Basics21.java], em que tratamos a exceção causada pela conversão em inteiro de uma string que não representa um inteiro:
Resultados:
Comentários:
- linha 4: se o fluxo de entrada estiver fechado, [IO.readln] retorna [null]; [Objects.requireNonNullElse] o substitui por uma string vazia;
- linhas 8–19: o laço de entrada da idade;
- linha 11: a linha digitada no teclado é convertida em inteiro pelo método [Integer.parseInt]. Esse método lança uma exceção [NumberFormatException] se a conversão não for possível, inclusive quando a string é [null]. É por isso que a operação foi colocada dentro de um [try / catch];
- linha 12: se chegamos a esta linha, a conversão foi bem-sucedida. No entanto, verificamos se o inteiro obtido é de fato maior ou igual a 1;
- linha 13: se uma exceção [NumberFormatException] for lançada, o controle passa para [catch], onde nada é feito. Assim, a variável booleana [ageOK], inicializada com [false], permanece em [false]. A variável de exceção, que não é usada, é a variável anônima _. Somente a exceção esperada é capturada: uma cláusula [catch (Exception _)] também mascararia erros que não foram previstos;
- linhas 16–18: uma mensagem de erro é exibida se a idade estiver incorreta.
Um número grande demais para um [int], como 99999999999, também dispara uma [NumberFormatException]: ele é, portanto, tratado como as demais entradas incorretas (segunda execução).
3.6.4. Várias cláusulas catch e lançamento de exceções
O próprio programa pode lançar uma exceção usando a instrução [throw]:
A execução do método atual é interrompida e a exceção é propagada pelos métodos chamadores até que uma cláusula [catch] a trate; se nenhuma o fizer, o programa termina, exibindo a exceção e a pilha de chamadas. Em uma cláusula [catch], a instrução [throw e;] relança a exceção atual—por exemplo, após registrá-la em log.
Java não possui filtro para cláusulas [catch]: para tratar uma exceção apenas em certos casos, testa-se a condição dentro da cláusula e relança-se a exceção, se necessário. Para verificar um parâmetro que não deve ser [null], use o método [Objects.requireNonNull(value, message)]: ele retorna o valor se não for nulo e, caso contrário, lança uma [NullPointerException] com a mensagem especificada.
O programa [Basics22.java] ilustra essas possibilidades:
Resultados:
Comentários:
- linha 3: entradas simuladas, válidas ou inválidas;
- linha 6: o método [readAge] (linhas 33–41) pode lançar vários tipos de exceções;
- linha 8: as entradas "abc", "" e "99999999999" disparam uma [NumberFormatException];
- linhas 10–14: na ausência de um filtro, a entrada vazia é distinguida dentro da cláusula [catch];
- linha 15: a exceção lançada pelo próprio [readAge] ;
- linha 24: [Objects.requireNonNull] lança uma [NullPointerException] se [name] for igual a [null]; sua mensagem é a passada como segundo parâmetro (linha 9 dos resultados);
- linha 38: o método [readAge] lança uma exceção se a idade estiver fora dos limites.
A ordem das cláusulas [catch] nas linhas 8 e 15 importa: a classe [NumberFormatException] deriva da classe [IllegalArgumentException] (uma [NumberFormatException] é um caso particular de argumento incorreto). Se as duas cláusulas forem invertidas, a cláusula [IllegalArgumentException] também intercepta as [NumberFormatException], e o compilador rejeita a cláusula que se tornou inacessível:
3.6.5. Exceções checked e unchecked
Eis uma característica importante do Java. As exceções são objetos cujas classes formam uma hierarquia:

- a classe raiz é [Throwable];
- a classe [Error] e suas subclasses indicam problemas graves da máquina virtual ([OutOfMemoryError], [StackOverflowError]...), que um programa normalmente não tenta capturar;
- a classe [RuntimeException] e suas derivadas ([NullPointerException], [ArithmeticException], [ArrayIndexOutOfBoundsException], [IllegalArgumentException], [NumberFormatException]...) geralmente indicam erros de programação ou dados incorretos;
- as demais classes derivadas de [Exception] ([IOException], [InterruptedException], [ParseException], [SQLException]...) informam incidentes causados pelo ambiente do programa (arquivo ausente, queda de rede, banco de dados fora do ar) que um programa correto deve prever.
As exceções desta última categoria são chamadas de "exceções checked": o compilador verifica se um método capaz de lançar uma delas, diretamente ou chamando outro método, a captura com uma cláusula [catch] ou a declara em sua assinatura com a palavra-chave [throws]:
A responsabilidade é então repassada aos métodos chamadores. As exceções derivadas de [RuntimeException] e de [Error] são chamadas de "unchecked": podem ser capturadas, mas o compilador não exige isso, e não é preciso declará-las. Muitas outras linguagens, como C# ou Kotlin, têm apenas exceções unchecked.
O programa [Basics23.java] ilustra esses diferentes casos:
Resultados:
Comentários:
- Linhas 36–38: o método [Files.readString] (capítulo 5) lê todo o conteúdo de um arquivo; ele pode lançar uma [IOException], que é checked. O método [readFile] não a intercepta: ele deve, portanto, declará-la com [throws IOException];
- linhas 4–9: por sua vez, o método [main], que chama [readFile], deve tratar a [IOException]. Como o arquivo não existe, a exceção lançada é uma [NoSuchFileException], uma classe derivada de [IOException], cuja mensagem é o nome do arquivo;
- linhas 41–43: [Thread.sleep] suspende o programa pelo tempo especificado em milissegundos; ela pode lançar uma [InterruptedException] (checked), que veremos no capítulo 8;
- linhas 11–16: a chamada a [waitFor] deve, portanto, ser colocada também em um [try / catch];
- linhas 46–48: uma divisão inteira pode provocar uma [ArithmeticException] unchecked; nenhuma cláusula [throws] é exigida;
- linhas 18–22: o chamador captura a exceção mesmo assim, porque assim o escolhe;
- linhas 51–57: uma técnica comum quando um método não pode ou não quer declarar uma exceção checked: interceptá-la e lançar em seu lugar uma exceção unchecked, neste caso uma [UncheckedIOException] (Java 8), passando a exceção original como sua causa;
- linha 27: [getCause()] devolve a exceção original;
- linhas 60–69: o método [ancestors] percorre a cadeia de classes pai de um objeto ([getSuperclass()]) até a classe [Object], a raiz de todas as classes;
- linhas 30–32: a hierarquia descrita acima se reflete nos resultados (linhas 6–8).
Se a cláusula [throws IOException] for removida da linha 36, o compilador rejeita o programa. Ele aponta tanto a exceção não tratada em [readFile] quanto a cláusula [catch], que se tornou redundante em [main], já que nenhum método chamado declara mais [IOException]:
O próprio método [main] pode lançar exceções: [void main() throws IOException]. Uma exceção não capturada encerra então o programa, que exibe a exceção e a pilha de chamadas e termina com código de retorno 1. Isso é aceitável para um pequeno programa de teste, mas não para uma aplicação de produção. As exceções checked às vezes são consideradas restritivas demais, e muitas bibliotecas recentes (Spring, Hibernate, que usaremos mais adiante) usam apenas exceções unchecked. Neste curso, capturamos uma exceção checked onde sabemos tratá-la e a encapsulamos em uma exceção unchecked nos demais casos.
3.6.6. Liberação de recursos: o bloco try com recursos
Um recurso (um arquivo aberto, uma conexão de rede, uma conexão com um banco de dados) deve ser fechado após o uso, mesmo que ocorra um erro durante sua utilização. Antes do Java 7, ele era fechado em uma cláusula [finally], o que exigia várias linhas de código complexo. O Java 7 introduziu a instrução try-with-resources:
O recurso declarado entre parênteses é fechado automaticamente (pela chamada de seu método [close()]) ao fim do bloco, quer ele termine normalmente, quer por causa de uma exceção. O tipo do recurso deve implementar a interface [AutoCloseable], que contém apenas o método [close()]; é o caso de todas as classes Java de arquivos, de rede e de banco de dados. É possível declarar vários recursos, separados por ponto e vírgula: eles são fechados na ordem inversa da abertura. Um [try] desse tipo pode ter cláusulas [catch] e [finally], que são executadas depois que os recursos são fechados.
O Java 7 também introduziu o multi-catch: uma única cláusula [catch] pode tratar vários tipos de exceção separados pelo caractere |: [catch (NumberFormatException | ArithmeticException e)]. Os tipos listados não podem ser derivados uns dos outros.
O programa [Basics24.java] é o seguinte:
Resultados:
Comentários:
- linha 2: o método [main] declara a exceção checked [IOException], que pode ser lançada pelo método [readLine] na linha 20 e que não capturamos;
- Linhas 39–44: um recurso de demonstração. Trata-se de um record (capítulo 4), uma classe muito simples na qual cada objeto tem um nome; ele implementa a interface [AutoCloseable] definindo o método [close()], que exibe uma mensagem;
- linhas 46–49: o método [open] exibe uma mensagem e cria um recurso;
- linhas 4–6: o recurso [r] é fechado automaticamente ao fim do bloco (linha 4 dos resultados);
- linhas 9–16: dois recursos. Uma exceção é lançada enquanto eles estão em uso (linha 11). Os resultados (linhas 5–11) mostram que R3 é fechado antes de R2, e que ambos são fechados antes da execução das cláusulas [catch] e [finally];
- linha 18: um [BufferedReader] que aqui lê uma string como se fosse um arquivo. Vamos usá-lo no capítulo 5 para ler arquivos de verdade;
- linha 20: [readLine()] devolve a próxima linha, ou [null] no fim do texto. A atribuição ocorre dentro da condição do [while]: o valor da expressão [(line = reader.readLine())] é o valor atribuído;
- Linha 31: um multi-catch: a mesma ação para uma [NumberFormatException] (linha 15 dos resultados) e para uma [ArithmeticException] (linha 16).
3.7. Aplicação de exemplo - V1
Queremos escrever um programa para calcular o imposto de um contribuinte. Consideraremos o caso simplificado de um contribuinte que tem apenas um salário a declarar. Os números são extraídos da tabela do imposto de 2004 sobre a renda de 2003 e são usados como estão: trata-se de um exercício de programação, não de um cálculo de impostos atuais. Esta aplicação será o nosso fio condutor: vamos retomá-la nos capítulos seguintes, incorporando classes, arquivos, um banco de dados e, depois, recursos de rede.
- Calculamos o número de cotas do empregado: cotas = nbChildren/2 + 1 se ele for solteiro, nbChildren/2 + 2 se for casado, onde nbChildren é o número de filhos;
- se ele tiver pelo menos três filhos, recebe meia cota adicional;
- sua renda tributável R é calculada como R = 0,72 * S, onde S é seu salário anual;
- seu quociente familiar é calculado como QF = R / cotas;
- seu imposto I é calculado com a tabela a seguir:
limite | coeffR | coeffN |
4962 | 0 | 0 |
8382 | 0.068 | 291.09 |
14,753 | 0.191 | 1,322.92 |
23,888 | 0.283 | 2,668.39 |
38,868 | 0.374 | 4,846.98 |
47,932 | 0.426 | 6,883.66 |
0 | 0.481 | 9,505.54 |
Cada linha tem 3 campos. Para calcular o imposto I, procuramos a primeira linha em que QF é menor ou igual ao limite. Por exemplo, se QF = 5000, encontraremos a linha:
O imposto I é então igual a 0,068 * R - 291,09 * cotas, arredondado para o euro mais próximo. Se QF for tal que a condição QF <= limite nunca é satisfeita, usam-se os coeficientes da última linha: I = 0,481 * R - 9505,54 * cotas. O limite 0 da última linha, portanto, nunca é usado.
Os cálculos envolvem valores monetários e coeficientes decimais: nós os realizamos com a classe [BigDecimal]. O programa Java correspondente, [Tax1.java], é o seguinte:
Comentários:
- Linhas 5–7: os três arrays de [BigDecimal] são construídos pelo método [decimals] (linhas 82–88) a partir de strings: cada valor, como 0.068, é, assim, exato. Com um [double], 0.068 seria apenas uma aproximação binária. O método [decimals] aceita qualquer número de parâmetros ([String... values]), que ele recebe em um array; essa notação é explicada na seção "Passagem de parâmetros para uma função";
- linhas 10–18: entrada do estado civil, em um laço [while (true)] que termina com [break] quando a resposta é válida;
- linha 12: o método [read] (linhas 77–79) exibe o prompt e lê a resposta; se o fluxo de entrada estiver fechado, o valor [null] é substituído por uma string vazia. O método [trim()] remove os espaços iniciais e finais da string lida, e [toLowerCase()] a converte para minúsculas. Isso permite aceitar tanto Y quanto y;
- linha 13: as strings são comparadas com [equals], nunca com ==;
- linha 16: as mensagens de erro são escritas no fluxo [System.err];
- linha 18: a variável booleana [married] recebe o valor [true] ou [false] a partir da expressão [answer.equals("y")];
- Linhas 21–32: entrada do número de filhos. [Integer.parseInt] lança uma [NumberFormatException] se a entrada não for um inteiro: o programa passa então para a cláusula [catch] (linha 28), que não faz nada, depois exibe a mensagem de erro e recomeça. Se a conversão for bem-sucedida e o número for positivo ou zero, o laço termina (linha 26). A variável [nbChildren], declarada sem valor na linha 21, sempre tem um valor ao sair do laço: o compilador verifica isso;
- linhas 35–46: o mesmo para o salário;
- linhas 49–50: o número de cotas é calculado em [BigDecimal]. Não se pode simplesmente escrever [nbChildren / 2]: se nbChildren for 3, obtém-se 3/2, uma divisão inteira que resultaria em 1 e não em 1,5. [BigDecimal.valueOf(nbChildren)] converte o inteiro, [divide(BigDecimal.TWO)] o divide por dois (a constante [TWO] existe desde o Java 19) e [add] soma 2 ou 1. As chamadas de método são encadeadas: cada uma se aplica ao resultado da anterior;
- linha 52: um [BigDecimal] é imutável: [add] não modifica [shares] , mas devolve um novo objeto, que deve ser atribuído à variável. Escrever apenas [shares.add(new BigDecimal("0.5"));] não teria nenhum efeito: é uma armadilha clássica;
- linha 56: a renda tributável;
- linha 59: o quociente familiar. Dividir a renda por 1,5 ou 3,5 cotas geralmente não resulta em uma representação decimal finita: definimos uma precisão, aqui [MathContext.DECIMAL128] (34 dígitos significativos), mais que suficiente;
- linhas 63–66: determinação da faixa de tributação. A busca para no primeiro limite superior maior ou igual ao quociente familiar, e o mais tardar na última faixa, graças à condição [i < limits.length - 1]. Os operadores < e > não se aplicam a [BigDecimal]: [quotient.compareTo(limits[i]) > 0] significa "quotient > limits[i]". Dois valores [BigDecimal] não se comparam com [equals], que leva em conta o número de casas decimais: 2.0 e 2.00 não são "iguais" para [equals];
- Linha 69: o valor do imposto é arredondado para o euro mais próximo com o método [intValue()], que descarta a parte decimal.
Aqui estão alguns exemplos de saída:
Para um salário anual de 60.000 euros, um contribuinte casado com 2 filhos paga 4.282 euros; com 3 filhos, 2.959 euros; e uma pessoa solteira sem filhos paga 11.519 euros. Na segunda execução, a entrada "60000 euros" é rejeitada: [Integer.parseInt] aceita apenas strings que representem exatamente um inteiro (os espaços iniciais e finais foram removidos por [trim()]).
3.8. Argumentos do programa principal
O método [main] pode receber como parâmetro um array de strings [String[]]. Esse array contém os argumentos da linha de comando usados para iniciar a aplicação. Assim, se iniciarmos o programa P com o comando:
e se o método [main] for declarado da seguinte forma:
teremos args[0]="arg0", args[1]="arg1" e assim por diante. Em um arquivo compacto, é possível obter o mesmo array declarando [void main(String[] args)]. Com o launcher de código-fonte, os argumentos do programa são colocados depois do nome do arquivo; as opções do próprio comando [java] (como [-cp] ou [-D]) são colocadas antes:
Eis um exemplo, [Basics25.java]:
Resultados:
Um argumento que contém espaços deve ser colocado entre aspas:
O mesmo programa escrito com uma classe e um método padrão:
Resultados:
Comentários:
- linha 2: uma classe pública, no arquivo [Basics26.java];
- linha 3: o ponto de entrada do programa, em sua forma padrão;
- linhas 4–7: o restante é idêntico a [Basics25.java], com [System.out.println] no lugar de [IO.println].
Uma aplicação organizada em pacotes coloca suas classes em pastas correspondentes aos nomes dos pacotes (capítulo 4); é também assim que se organizam os projetos Maven, que começaremos a usar no capítulo 5. Observe, por fim, que em Java o método [main] não devolve um valor: o código de saída do programa é definido com [System.exit].
3.9. Enumerações
Uma enumeração é um tipo de dados cujo domínio de valores é formado por um conjunto de constantes nomeadas. Considere um programa que precisa tratar menções de provas. Há cinco menções possíveis: Pass, Fairly Good, Good, Very Good e Excellent. Podemos então definir uma enumeração para essas cinco constantes:
Por convenção, os nomes das constantes são escritos em maiúsculas. Uma variável pode ser declarada para tomar seus valores da enumeração:
É possível comparar uma variável com os diferentes valores possíveis da enumeração usando o operador ==:
Ao contrário de outras linguagens em que uma enumeração é simplesmente um conjunto de inteiros nomeados, uma enumeração Java é uma classe, derivada da classe [java.lang.Enum], cujos únicos objetos são as constantes declaradas. Cada constante é um objeto único, criado uma vez por todas; é por isso que elas podem ser comparadas com ==. Cada constante conhece seu nome ([name()], ou [toString()]) e seu número de ordem na declaração ([ordinal()], a partir de 0). O compilador adiciona dois métodos estáticos a toda enum:
- [Honours.values()] devolve o array das constantes da enumeração [Honours], na ordem em que foram declaradas;
- [Honours.valueOf(name)] devolve a constante de nome [name], e lança uma [IllegalArgumentException] se nenhuma constante tiver esse nome.
Uma enumeração não pode ser convertida em inteiro, nem um inteiro em enumeração: é preciso usar [ordinal()] e [values()].
O programa [Basics27.java] destaca o que acabou de ser escrito:
Resultados:
Comentários:
- linha 2: a declaração da enumeração. Em um arquivo compacto, ela é colocada ao lado dos métodos; em um programa organizado em classes, ela é declarada, como uma classe (capítulo 4), em seu próprio arquivo, [Honours.java];
- linha 6: uma variável do tipo [Honours];
- linha 8: uma constante de enumeração é exibida pelo seu nome;
- linhas 14–16: a lista das constantes e seus números de ordem;
- linha 18: a conversão de um número de ordem em constante;
- linha 21: a conversão de uma string em constante de enumeração;
- linha 22: as constantes são comparadas com [compareTo] segundo sua ordem de declaração: GOOD vem depois de PASS;
- linhas 23–27: [valueOf] diferencia maiúsculas de minúsculas: "Good" não é o nome de uma constante;
- linhas 29–33: as enumerações combinam bem com as instruções switch. As cláusulas [case] usam os nomes das constantes sem prefixá-los com [Honours]. Como todas as constantes são cobertas, a expressão é exaustiva sem uma cláusula [default]; se uma constante for adicionada à enumeração mais tarde, o compilador sinalizará a expressão switch como incompleta;
- linha 35: o nome completo da enumeração é [Basics27$Honours]: em um arquivo compacto, a enumeração é um tipo membro da classe implícita [Basics27], e o caractere $ separa os dois nomes;
- linha 36: a classe pai de qualquer enumeração é [java.lang.Enum].
3.9.1. Enumerações enriquecidas
Como uma enumeração é uma classe, ela pode ter campos, um construtor e métodos. Cada constante é então criada pela chamada do construtor com os parâmetros escritos entre parênteses após o seu nome. Este é um recurso muito usado em Java, que elimina a necessidade de gerenciar separadamente arrays de valores associados às constantes.
Para representar um conjunto de opções, como as permissões de acesso a um arquivo (leitura, escrita, execução), antigamente combinavam-se potências de 2 com o operador | (OU bit a bit). Em Java, usamos uma enum e a classe [EnumSet], um conjunto de constantes de uma enum, que é tão eficiente quanto uma combinação bit a bit (internamente, é uma) mas muito mais legível. A classe [EnumMap] é, da mesma forma, um dicionário cujas chaves são as constantes de uma enumeração.
O programa [Basics28.java] é o seguinte:
Resultados:
Comentários:
- linhas 4–8: as constantes da enumeração, cada uma com seus dois parâmetros. O ponto e vírgula após a última constante é obrigatório quando há membros em seguida;
- linhas 11–12: os campos de cada constante. Eles são [private] (acessíveis apenas dentro da enumeração) e [final] (definidos uma vez por todas);
- linhas 15–18: o construtor, chamado uma vez para cada constante quando a enumeração é usada pela primeira vez. A palavra-chave [this] designa o objeto em construção: [this.minimumGrade] é o campo, e [minimumGrade] é o parâmetro. O construtor de uma enumeração é implicitamente privado: não é possível criar constantes adicionais;
- linhas 20–26: dois métodos que devolvem os valores dos campos. Os nomes [getMinimumGrade] e [getLabel] seguem a convenção Java de getters e setters, descrita no capítulo 4;
- linhas 29–37: um método estático, chamado na própria enum ([Honour.forGrade(grade)]). Como as constantes são declaradas em ordem crescente de nota, a última a atingir a nota mínima é a correta. O resultado é um [Optional], que está vazio se a nota for inferior a 10;
- linha 41: uma enumeração simples para direitos de acesso;
- linhas 44–46: a lista das entradas com seus campos;
- linha 49: [map(Honour::getLabel)] transforma [Optional<Honour>] em [Optional<String>] contendo o rótulo; [orElse] fornece um texto quando o [Optional] está vazio;
- linha 54: um conjunto de dois direitos;
- linhas 55–56: o método [contains] verifica se uma constante pertence ao conjunto, como se verificaria um bit;
- linhas 57–58: constantes são adicionadas e removidas;
- linhas 60–61: o conjunto de todas as constantes, o conjunto vazio e o complemento de um conjunto;
- linha 62: as constantes entre duas constantes, na ordem em que foram declaradas;
- linhas 65–68: um [EnumMap] associa um conjunto de valores a certas entradas. Suas chaves são sempre percorridas na ordem em que as constantes foram declaradas: PASS aparece antes de GOOD, embora tenha sido adicionada depois. Os dicionários são tratados no capítulo 5.
3.10. Passagem de parâmetros para uma função
Em Java, as funções são chamadas de métodos: elas sempre pertencem a uma classe, possivelmente à classe implícita de um arquivo compacto. Aqui, nos concentramos na maneira como os parâmetros são passados a um método. Considere o seguinte método:
Na definição do método, na linha 1, [a] é chamado de parâmetro formal. Ele existe apenas para definir o método [changeInt]. Poderia muito bem ter sido chamado de [b]. Consideremos agora uma chamada a esse método:
Aqui, na instrução da linha 2, [age] é o parâmetro real que passará seu valor ao parâmetro formal [a]. Interessa-nos saber como um parâmetro formal obtém o valor de um parâmetro real.
3.10.1. Passagem por valor: o único modo de passagem de parâmetros do Java
O Java tem apenas um modo de passagem de parâmetros: a passagem por valor. O valor do parâmetro real é copiado para o parâmetro formal correspondente. São duas entidades distintas: se o método modificar o parâmetro formal, o parâmetro real permanece inalterado.
Quando o parâmetro é de um tipo referência (um array, um objeto), o valor copiado é a referência: o parâmetro formal e o parâmetro real passam então a referir-se ao mesmo objeto. O método pode, portanto, modificar esse objeto, se ele for modificável, e o chamador verá a alteração; no entanto, ele não pode fazer a variável do chamador referir-se a outro objeto.
Ao contrário de outras linguagens, o Java não oferece passagem por referência, em que o parâmetro formal e o parâmetro real seriam uma única e mesma variável: um método não pode modificar uma variável local de seu chamador, nem "devolver" resultados ao chamador por meio de seus parâmetros. Em vez disso, usamos:
- o valor de retorno do método, que o chamador atribui à sua variável;
- um record quando o método precisa devolver vários valores;
- um array ou um objeto mutável passado como parâmetro, no qual o método coloca seus resultados.
Além disso, um parâmetro declarado como [final] não pode receber um novo valor dentro do método: o compilador garante assim que ele conserve o valor passado pelo chamador.
O programa [Basics29.java] ilustra esses diferentes casos:
Resultados:
Comentários:
- linhas 4–6: o valor 20 do parâmetro real [age] foi copiado para o parâmetro formal [a] (linha 44). Esse parâmetro foi então modificado (linha 45). O parâmetro real permaneceu inalterado;
- linhas 9–11: o método [changeInt2] (linhas 49–53) devolve seu novo valor, que o chamador atribui à sua própria variável [age2];
- linha 42: um record (Java 16) declara, em uma única linha, uma classe cujos objetos contêm dois valores imutáveis, [succeeded] e [value]. O compilador adiciona um construtor, um método getter para cada um dos dois valores ([succeeded()], [value()]), e um método chamado [toString()]. Os records são tratados no capítulo 4;
- linhas 14–19: o método [convert] (linhas 55–61) devolve duas informações, se a conversão foi bem-sucedida e o valor resultante, reunidas em um objeto [Conversion]. Seu método [toString()] exibe seus componentes;
- linhas 22–24: a troca de dois valores. Um método chamado [swap(int a, int b)] trocaria cópias sem nenhum efeito sobre o chamador; por isso, os dois valores são armazenados em um array, que o método [swap] (linhas 63–67) modifica;
- Linhas 27–29: a referência ao array é passada por valor. O método [modifyArray] opera, portanto, sobre o mesmo array do chamador: a modificação feita por [t[0]] (linha 71) é visível ao chamador. No entanto, fazer [t] apontar para outro array (linha 73) modifica apenas a cópia local da referência;
- linhas 32–34: um objeto [StringBuilder] é uma string mutável: o método [complete] (linhas 77–79) acrescenta texto a ele, e o chamador vê o resultado. Com uma [String], isso teria sido impossível: os objetos [String] são imutáveis;
- linhas 37–38: o método [inclTax] (linhas 81–84) tem um parâmetro [final]. O produto de dois objetos [BigDecimal] tem tantas casas decimais quanto a soma das de seus dois fatores: 100 × 1,2 = 120,0, exibido como 120.0.
Se o comentário da linha 82 for substituído pela instrução [amount = BigDecimal.ZERO;], o compilador rejeita o programa:
3.10.2. Sobrecarga de métodos, número variável de parâmetros
O Java não tem parâmetros opcionais com valores padrão, nem argumentos nomeados. O equivalente dos parâmetros opcionais é obtido por meio da sobrecarga de métodos: vários métodos podem ter o mesmo nome se suas listas de parâmetros diferirem em número ou em tipo; o compilador seleciona o adequado com base nos parâmetros reais fornecidos. Na maioria das vezes, as versões curtas chamam a versão completa, passando-lhe valores padrão. Quando há muitos parâmetros opcionais, prefere-se um objeto de configuração ou um "builder"; veremos exemplos disso mais adiante no curso.
O Java 5 introduziu métodos com um número variável de parâmetros ("varargs"): o último parâmetro formal é declarado com reticências, [int... numbers]. O chamador pode passar um array ou uma lista de valores (possivelmente vazia), que o compilador organiza em um array; dentro do método, o parâmetro é um array.
O programa [Basics30.java] é o seguinte:
Resultados:
Comentários:
- Linhas 21–32: três métodos [greet] que diferem no número de parâmetros que recebem. Só o último faz o trabalho; os outros dois o chamam com valores padrão para os parâmetros ausentes;
- linha 4: [greet("Pierre")] chama a versão de um parâmetro (linha 21), que chama a versão de dois parâmetros com a string "Hello,", que por sua vez chama a versão completa com [false];
- Linhas 6–7: sem argumentos nomeados, para passar [uppercase], é preciso passar também [greeting];
- linhas 34–41: [sum] aceita qualquer quantidade de inteiros, recebidos no array [numbers];
- linhas 10–13: [sum] é chamado sem parâmetros, com três inteiros e depois com um array;
- linhas 15–17: muitos métodos do JDK têm um número variável de parâmetros: [String.join], [String.format], [List.of]...
3.11. Funções locais e tuplas: soluções em Java
3.11.1. Métodos, lambdas e classes locais
Algumas linguagens permitem definir uma função local, isto é, uma função escrita dentro de outra função e utilizável apenas nesse contexto. O Java não permite isso. Em nossos arquivos compactos, os métodos do arquivo cumprem esse papel; em uma classe, escrevemos métodos privados. Dentro de um método, temos duas ferramentas à disposição:
- uma lambda (Java 8), uma pequena função anônima armazenada em uma variável de um tipo adequado, chamado interface funcional: [IntUnaryOperator cube = x -> x * x * x;]. As lambdas são tratadas no capítulo 7, "Interfaces funcionais, lambdas e eventos". Uma lambda pode ler as variáveis locais ao seu redor, mas apenas se elas nunca forem modificadas (variáveis [final] ou "efetivamente final"); ela não pode modificá-las;
- uma classe local, declarada dentro do método e utilizável apenas nele.
3.11.2. Records em vez de tuplas
Outras linguagens têm tuplas, que agrupam vários valores sem exigir a declaração de um tipo. O Java não as tem: ele usa records (Java 16). A declaração [record Couple(int number, String name) {}] cria, em uma única linha, uma classe em que cada objeto é formado por um inteiro e uma string, com um construtor, os métodos de acesso [number()] e [name()], e os métodos [toString()], [equals()], e [hashCode()]. Um record pode ser declarado dentro de um método (record local). Seus componentes podem ser extraídos com um padrão de record (Java 21), com o operador [instanceof] ou dentro de um [switch]. Os records são a maneira natural de fazer um método devolver vários valores; como seus componentes têm nomes, eles são mais legíveis que as tuplas.
O programa [Basics31.java] é o seguinte:
Resultados:
Comentários:
- linha 4: o método [square] (linhas 56–58) do arquivo compacto;
- linha 6: uma lambda. [x -> x * x * x] lê-se "a função que associa x a x * x * x". Ela é armazenada em uma variável do tipo [IntUnaryOperator], que representa uma função de um [int] para um [int] (pacote [java.util.function]);
- linha 7: a lambda é chamada pelo método [applyAsInt] da interface [IntUnaryOperator];
- linhas 10–14: uma lambda do tipo [Runnable] (sem parâmetros nem valor de retorno), chamada por [run()]. Ela não pode modificar uma variável local [int]; no entanto, pode modificar o conteúdo de um objeto, neste caso um array de um único elemento. Com [int counter = 0;] e [() -> counter++], o compilador teria rejeitado o programa: [error: local variables referenced from a lambda expression must be final or effectively final];
- linhas 17–23: uma classe local [Accumulator], com um campo [total] e um método [add]. As classes são tratadas no capítulo 4;
- linhas 24–27: um objeto [Accumulator] é criado com o operador [new] e, em seguida, seu método é chamado. O campo privado [total] permanece acessível ao código do método que contém a classe;
- linha 30: um record local;
- linha 32: o método [toString()] de um record exibe o nome do record e seus componentes; os métodos [number()] e [name()] devolvem os componentes;
- linhas 34–37: um padrão de record: se [object] for um [Couple], seus dois componentes são armazenados nas variáveis [number] e [name], declaradas no padrão. O Java 25 não tem uma instrução que decomponha diretamente um record em várias variáveis;
- linhas 39–40: para um simples par chave-valor, a biblioteca fornece [Map.entry(key, value)], cujos componentes são obtidos por [getKey()] e [getValue()];
- linhas 43–46: os métodos [divide] e [minMax] (linhas 64–75) devolvem, cada um, dois valores, reunidos em um record declarado nas linhas 60 e 62. Os nomes dos componentes ([quotient()], [remainder()], [min()], [max()]) tornam explícito o código chamador;
- linhas 49–53: sem tuplas, duas variáveis são trocadas por meio de uma variável temporária;
- linhas 71–72: uma instrução [if] cuja única ação é escrita na mesma linha, sem chaves.
Em um programa maior, definimos classes, que reúnem os dados e os métodos que os manipulam: este é o tema do próximo capítulo.