Skip to content

1. Introdução

O PDF deste documento está AQUI.

Os códigos deste documento estão AQUI.

Este documento é um produto da IA Claude, da Anthropic. É o port para Java do curso “Aprendendo a linguagem C# 14 com .NET 10” (outubro de 2026), que por sua vez é uma reescrita do curso “Aprendendo a linguagem C# versão 3.0 com o .NET 3.5 escrito por Serge Tahé em maio de 2008. Ele mantém o roteiro, os exemplos e o fio condutor do curso, e os reescreve em Java moderno:

  • o documento usa Java 25 (setembro de 2025), a última versão de suporte de longo prazo do Java (LTS), e apresenta, ao longo dos capítulos, os recursos novos da linguagem, dos arquivos-fonte compactos do Java 25 às threads virtuais do Java 21, passando por records, classes seladas e pattern matching;
  • onde as duas linguagens diferem, o documento faz mais do que simplesmente traduzir: as propriedades, as estruturas, a sobrecarga de operadores e os delegates do C# não existem em Java, que tem suas próprias soluções (getters, records, interfaces funcionais); inversamente, o Java possui conceitos que lhe são próprios, como as exceções verificadas e as threads virtuais, e eles são apresentados em detalhe;
  • Dois capítulos têm um enfoque diferente: a programação assíncrona, que o Java trata com as classes [CompletableFuture] e as threads virtuais, e não com as palavras-chave [async] / [await], e o mapeamento objeto-relacional, fornecido pelo Hibernate, o ORM mais usado no mundo Java;
  • as bibliotecas são as usadas atualmente em Java: [JUnit 6] para os testes, [Spring Framework 7] para a injeção de dependência, [Jackson 3] para o JSON, o driver [MySQL Connector/J] para o JDBC, [Hibernate 7] e [Spring Boot 4] para os serviços web; os projetos são construídos com [Maven].

Este documento não é um curso exaustivo. Como aqueles dos quais deriva, destina-se a pessoas que já sabem programar e querem aprender o essencial de Java. Ele se apoia em exemplos: mais de duzentos programas (mais de trezentos arquivos Java), a maioria curtos, com comentários linha a linha.

1.1. O Java de 1995 a 2026

O Java foi lançado pela Sun Microsystems em maio de 1995. Baseia-se em uma ideia que foi decisiva para seu sucesso: o compilador [javac] não produz código de máquina, mas um código intermediário, o bytecode, armazenado em arquivos [.class], que a Máquina Virtual Java (a JVM, “Java Virtual Machine”) executa compilando-o em tempo de execução em código de máquina. Um mesmo programa compilado pode, assim, rodar no Windows, no Linux ou no macOS: “escreva uma vez, execute em qualquer lugar”. As linguagens Kotlin, Scala e Groovy também produzem bytecode e usam as mesmas bibliotecas.

Marcos principais:

  • 2006–2007: OpenJDK. A Sun libera o código-fonte do Java sob uma licença de código aberto (JDK). Todas as distribuições atuais do Java são construídas a partir do OpenJDK;
  • 2010: a Oracle adquire a Sun e se torna a principal contribuidora do Java;
  • 2014: Java 8, uma versão decisiva: expressões lambda, Stream API, nova API de data e hora. Muitos programas em produção ainda são escritos nesse estilo;
  • Desde 2017 (Java 9): uma nova versão do Java é lançada a cada seis meses, em março e setembro. Algumas versões têm suporte de longo prazo (LTS, “Long-Term Support”): Java 11 (2018), 17 (2021), 21 (2023) e 25 (setembro de 2025), que é a usada neste documento; a partir do Java 17, uma nova versão LTS é lançada a cada dois anos. As demais versões são suportadas por apenas seis meses; os novos recursos costumam aparecer primeiro como “previews” antes de serem finalizados em uma versão posterior;
  • O JDK é distribuído por vários fornecedores, todos baseados no OpenJDK e equivalentes para nossos propósitos: Oracle, Eclipse Foundation (Eclipse Temurin, projeto Adoptium), Microsoft, Amazon (Corretto) e distribuições Linux.

A linguagem evoluiu muito desde o Java 8. A tabela a seguir resume os principais recursos novos apresentados neste documento e indica o capítulo em que aparecem:

Versão
Ano
Principais novidades
Capítulo
Java 8
2014
expressões lambda, referências a métodos, Stream API, métodos em interfaces, [default], [java.time], [CompletableFuture]
5, 7, 9
Java 9
2017
módulos (JPMS), [jshell], coleções imutáveis [List.of], [Map.of]
2, 4, 5
Java 10
2018
Inferência de tipo para variáveis locais [var]
3
Java 11
2018
cliente HTTP [java.net.http.HttpClient], execução direta de um arquivo-fonte [java File.java], métodos de [strip], [repeat], [lines] strings
2, 5, 12
Java 14
2020
expressões [switch] ([case ->], [yield]), mensagens detalhadas para [NullPointerException]
3, 4
Java 15
2020
blocos de texto ["""]
3
Java 16
2021
records, filtragem por padrão com [instanceof]
4
Java 17
2021
Classes e interfaces seladas ([sealed], [permits])
4
Java 18
2022
UTF-8 como codificação padrão
5
Java 21
2023
Threads virtuais, coleções sequenciadas, filtragem por padrão em [switch], padrões de record
3, 4, 5, 8, 9
Java 22
2024
Variáveis e parâmetros anônimos [_], execução de programas com vários arquivos-fonte
3, 4, 7
Java 24
2025
Operações intermediárias de stream ([Gatherers])
5, 7
Java 25
2025
Arquivos-fonte compactos e métodos de instância ([main]), classe ([IO]), importação de módulos, valores com escopo ([ScopedValue])
2, 3, 8

Em termos de bibliotecas e ferramentas, as novidades apresentadas incluem: a ferramenta de build [Maven], as coleções modernas, a Stream API, a API de arquivos [java.nio.file], as classes de [java.util.concurrent], o cliente HTTP do Java 11 e os principais frameworks do ecossistema: JUnit, Spring, Jackson, Hibernate e Spring Boot.

1.2. Conteúdo do documento

O documento inclui os seguintes capítulos:

  • Capítulo 2: configuração do ambiente de desenvolvimento (JDK 25, IntelliJ IDEA ou VS Code, Maven, os comandos [java] e [javac] );
  • Capítulo 3: fundamentos da linguagem (tipos, operadores, instruções de controle, exceções verificadas e não verificadas, enumerações, passagem de parâmetros);
  • Capítulo 4: classes, records, interfaces, herança, classes seladas, generics, pacotes, pattern matching;
  • Capítulo 5: classes Java de uso frequente: strings, arrays, coleções, Stream API, arquivos de texto e binários, JSON com Jackson, expressões regulares;
  • Capítulo 6: arquiteturas em camadas, testes unitários com JUnit 6 e injeção de dependência com Spring;
  • Capítulo 7: interfaces funcionais, expressões lambda e eventos;
  • Capítulo 8: threads de execução, sincronização e threads virtuais;
  • Capítulo 9: programação assíncrona com [CompletableFuture] e threads virtuais;
  • Capítulo 10: acesso a bancos de dados com JDBC;
  • Capítulo 11: Hibernate;
  • Capítulo 12: programação web (TCP/IP, clientes e servidores TCP, HTTP com [HttpClient]);
  • Capítulo 13: serviços web com Spring Boot;
  • Capítulo 14: indo além;
  • Apêndices: instalação do Laragon e do MySQL, as dependências Maven utilizadas.

1.3. O fio condutor: o cálculo do imposto

O mesmo problema é retomado ao longo do documento: calcular o imposto de renda de um contribuinte que tem apenas o salário a declarar. A tabela de alíquotas usada é a original (rendimentos de 2003): não está mais em vigor, mas basta para nosso propósito, que é escrever a mesma aplicação de várias maneiras diferentes. Ela é implementada em nove versões:

Versão
Capítulo
Conteúdo
1
3
Um único programa: entrada validada, cálculo, exibição
2
4
Classes e interfaces: [TaxBracket], [ITax], [AbstractTax], [HardwiredTax]
3
5
dados de cálculo lidos de um arquivo de texto ou de um arquivo JSON
4
6
Uma arquitetura em camadas ([dao], [business], [ui]) dentro de um único programa
5
6
Um módulo Maven por camada, testes unitários e integração das camadas por injeção de dependência
6
10
uma camada [dao] que lê os dados de um banco de dados MySQL com JDBC
7
11
uma camada [dao] escrita com Hibernate
8
12
um servidor TCP de cálculo de imposto e seu cliente
9
13
um serviço web REST de cálculo de imposto, um cliente de console e um cliente web

A partir da versão 5, as versões seguintes reutilizam as camadas da versão 5 e substituem apenas a camada que muda: esse é todo o interesse da arquitetura em camadas apresentada no Capítulo 6.

1.4. Exemplos

O código deste documento está organizado em uma única pasta chamada [java-oct-2026], com uma subpasta por capítulo:

java-oct-2026/
├── 02-installation/       first program, first Maven projects
├── 03-basics/             Basics01.java to Basics31.java, Tax1.java
├── 04-classes/            Classes01.java to Classes26.java, multi-file programs, TaxV2
├── 05-classes-java/       strings, arrays, collections, Stream API, files, JSON, regex, TaxV3
├── 06-architectures/      DemoTests, TaxV4, TaxV5 (layers, tests, dependency injection)
├── 07-lambdas/            Lambdas01.java to Lambdas11.java
├── 08-threads/            Threads01.java to Threads31.java
├── 09-async/              Async01.java to Async26.java
├── 10-jdbc/               SQL scripts, jdbc project (Jdbc01 to Jdbc10), TaxV6
├── 11-hibernate/          Hibernate projects, TaxV7
├── 12-internet/           Internet01.java to Internet19, TaxV8
└── 13-web-services/       Spring Boot web services and their clients (WsTax, ClientWsTax: version 9)

Os programas pequenos são arquivos-fonte compactos: um único arquivo chamado [.java], executado com o comando [java File.java] (Capítulo 2). Os programas com vários arquivos que usam apenas as bibliotecas do JDK são iniciados da mesma forma. Os programas que exigem uma biblioteca externa (Jackson, JUnit, Spring, o driver MySQL, Hibernate, Spring Boot) são projetos Maven ([pom.xml]).

Todos os programas deste documento foram compilados sem erros nem avisos pelo compilador [javac] do JDK 25, com a opção [-Xlint:all] que ativa todos os avisos, e executados com as versões de biblioteca listadas no apêndice. Os resultados reproduzidos neste documento são os dessas execuções. Os dos Capítulos 2 a 4 foram obtidos com a configuração de idioma e país do francês (fr-FR), como em um Windows em francês: os números de ponto flutuante formatados são exibidos com vírgula decimal e as datas aparecem em francês; os capítulos seguintes foram executados com a configuração em inglês (ponto decimal, datas em inglês). Duas observações:

  • as mensagens de erro do JDK (mensagens de exceção, mensagens do compilador) estão em inglês: o JDK não oferece tradução para o francês;
  • os exemplos foram executados no Linux. Na maior parte, isso não faz diferença: o Java é multiplataforma. As poucas diferenças (caminhos de arquivo com / em vez de \, comandos de terminal) são indicadas onde ocorrem.

Os resultados de programas com várias threads, assíncronos ou de rede, bem como os tempos de execução medidos, podem variar de uma execução para outra: os comentários se concentram no que é reproduzível.

1.5. Fontes

As principais fontes deste documento são: