Da Primeira Classe à JVM: o Mapa da Jornada em Java

Antes da primeira linha de código, o plano inteiro: o que você vai aprender, em que ordem e por que cada trecho vem onde está.

Todo curso longo precisa de um mapa, e este tem setenta e oito aulas. Você vai começar escrevendo uma frase no terminal. Ao fim do núcleo do curso, vai ter construído um servidor web inteiro com as próprias mãos, lendo byte a byte o protocolo que o navegador envia. Nas trilhas de extensão, o mesmo conhecimento vira uma API com banco de dados, um site completo, um aplicativo de desktop, um app de celular e um jogo de plataforma. Tudo isso numa linguagem que tem trinta anos, roda em bilhões de dispositivos e nunca esteve tão moderna quanto hoje.

Este artigo não ensina sintaxe. É o guia que você vai reabrir sempre que se perguntar "onde estou e o que vem depois".

Por que Java, e por que agora

Java tem uma reputação ambígua. Para muita gente, é a linguagem "verbosa" e "corporativa" dos sistemas de banco, cheia de cerimônia, que exige três linhas para imprimir uma frase. Essa imagem tinha fundamento há quinze anos. Hoje ela está desatualizada.

Desde 2017 a linguagem ganha uma versão nova a cada seis meses. Nesse período vieram, entre outras coisas, os records (classes de dados em uma linha), o pattern matching, as sealed classes, os text blocks, as virtual threads, que permitem milhões de tarefas simultâneas com código simples, e, no Java 25, um jeito de escrever o primeiro programa sem nenhuma cerimônia. O Java que você vai aprender aqui é esse, o de 2025 em diante, e não o dos livros de 2005.

O que não mudou é o motivo de o Java estar em toda parte. A máquina virtual Java, a JVM, é uma das peças de software mais estudadas e otimizadas já construídas. O ecossistema de bibliotecas é o maior e mais maduro do mundo corporativo. E a compatibilidade é levada a sério: código escrito há vinte anos ainda compila e roda. Aprender Java é aprender a linguagem, mas também uma plataforma inteira que sustenta bancos, governos, sistemas de big data, o Android e até o Minecraft.

Como esta série pensa

Este curso parte do zero. Você não precisa ter programado antes. Se já programou, em C, C# ou qualquer outra linguagem, vai encontrar comparações pontuais que ajudam a situar o que é igual e o que é diferente em Java. Mas nada será pressuposto.

Algumas regras guiam todas as aulas:

• Cada conceito aparece só depois da base que ele exige. Não vamos usar algo que ainda não foi explicado "porque depois você entende". Quando for inevitável adiantar alguma coisa, isso será dito com todas as letras.
• Todo código roda. Os exemplos são programas completos, testados no Java 25, e a saída esperada aparece quando ajuda.
• O porquê importa tanto quanto o como. Cada recurso vem acompanhado do problema que ele resolve, do custo que ele tem e de quando não usá-lo.
• As aulas conversam entre si. Uma ideia plantada numa aula volta, crescida, dez aulas depois. O curso é uma jornada só, não uma pilha de tópicos soltos.
• A versão é o Java 25, a versão de suporte longo (LTS) mais recente. Quando um recurso depender de versão, ou ainda estiver em preview, isso será dito.

Cada aula termina com fontes para ir além e cinco exercícios, do mais simples ao mais exigente, cada um com a resposta comentada logo abaixo. Tente resolver antes de ler a resposta. É no exercício que o conhecimento fixa.

O mapa: nove fases e três trilhas

O núcleo do curso tem nove fases e termina no artigo 52, com o projeto final e a retrospectiva. Depois vêm três trilhas de extensão, que levam o Java aos lugares onde ele mais trabalha no mundo real.

Fase 1: Primeiros passos na JVM (01 a 07). De onde o Java veio, como instalá-lo, o que acontece entre o código-fonte e a execução, e os blocos básicos de qualquer programa: valores, operações, decisões, repetições, métodos e arrays.

1. Uma Linguagem para Torradeiras que Conquistou o Mundo — a História do Java
2. Do Código ao Bytecode — JDK, javac, JVM e o Primeiro Programa
3. Cada Valor em sua Caixa — Tipos Primitivos, Variáveis e Conversões
4. Operadores, Texto e Conversa com o Usuário — Expressões, Strings e Entrada
5. O Programa que Escolhe e Repete — if, switch e Laços
6. Dividir para Resolver — Métodos, Parâmetros e Recursão
7. Muitos Valores sob um Nome — Arrays

Fase 2: Objetos (08 a 15). O coração do Java. Classes e objetos, encapsulamento, herança, interfaces e polimorfismo, e depois os recursos modernos que tornaram a modelagem de dados muito mais concisa: records, enums, sealed classes e pattern matching.

8. Moldes e Instâncias — Classes, Objetos e Construtores
9. O que Fica Dentro, o que Fica Fora — Encapsulamento e Modificadores de Acesso
10. Do Geral ao Específico — Herança e a Classe Object
11. Contratos sem Implementação — Interfaces e Classes Abstratas
12. Um Tipo, Várias Formas — Polimorfismo na Prática
13. Iguais ou o Mesmo? — equals, hashCode e Identidade
14. Dados sem Cerimônia — Records e Enums de Verdade
15. Hierarquias Fechadas — Sealed Classes e Pattern Matching

Fase 3: A biblioteca padrão (16 a 22). Genéricos e as coleções que você vai usar todos os dias, o tratamento de erros com exceções, arquivos e as ferramentas certas para datas, dinheiro e padrões de texto.

16. Escreva uma Vez para Todo Tipo — Genéricos
17. O Preço da Compatibilidade — Wildcards e Type Erasure
18. Listas, Conjuntos e Mapas — o Collections Framework
19. Ordem e Critério — Comparable, Comparator e Coleções Ordenadas
20. Quando o Contrato se Quebra — Exceções Verificadas e Não Verificadas
21. Recursos que se Fecham Sozinhos — try-with-resources, Arquivos e NIO.2
22. Tempo, Dinheiro e Padrões — java.time, BigDecimal e Expressões Regulares

Fase 4: Java funcional (23 a 27). Comportamento tratado como valor. Lambdas, a API de Streams, o Optional, e as anotações e a reflexão, que são o mecanismo por trás de quase todo framework Java.

23. Comportamento como Valor — Lambdas e Interfaces Funcionais
24. Pare de Escrever Laços — a API de Streams
25. Agrupar, Achatar, Reduzir — Collectors e Gatherers
26. Um Valor que Pode Não Existir — Optional e a Guerra contra o null
27. O Programa que se Examina — Anotações e Reflexão

Fase 5: Projetos e ferramentas (28 a 32). Do arquivo solto ao projeto profissional: pacotes, JARs, Maven e Gradle, o sistema de módulos e os testes automatizados que permitem mudar o código sem medo.

28. Do Arquivo Solto ao Projeto — Pacotes, Classpath e JARs
29. Construção Automatizada — Maven e Gradle
30. Fronteiras Explícitas — o Sistema de Módulos
31. Provando que Funciona — Testes com JUnit e AssertJ
32. Dublês e Disciplina — Mockito e Testes que Não Mentem

Fase 6: Por dentro da JVM (33 a 36). Como a máquina virtual carrega, executa e otimiza o seu código. Como o coletor de lixo trabalha. Como medir desempenho de verdade, e como o Java conversa com código nativo escrito em C.

33. A Máquina por Trás da Máquina — Class Loading, Pilha, Heap e JIT
34. Quem Recolhe o Lixo — os Coletores G1 e ZGC
35. Medir Antes de Otimizar — JFR, Mission Control e JMH
36. Ponte para o Nativo — a Foreign Function & Memory API

Fase 7: Concorrência (37 a 43). Fazer várias coisas ao mesmo tempo sem corromper dados. Das threads clássicas e do modelo de memória até as virtual threads e a concorrência estruturada, que mudaram a forma de escrever servidores em Java.

37. Fazendo Duas Coisas ao Mesmo Tempo — Threads
38. O Cadeado e a Memória — synchronized, volatile e o Java Memory Model
39. Não Crie Threads, Entregue Tarefas — ExecutorService e Futures
40. Ferramentas de Precisão — Locks, Atomics e Coleções Concorrentes
41. Encadeando o que Ainda Não Aconteceu — CompletableFuture
42. Um Milhão de Threads — Virtual Threads
43. Tarefas em Família — Structured Concurrency e Scoped Values

Fase 8: Qualidade e distribuição (44 a 46). O que a comunidade aprendeu em trinta anos sobre escrever Java bom, e como entregar um programa pronto para quem nem tem Java instalado.

44. Lições de Quem Veio Antes — Effective Java, Código Limpo e Padrões
45. Contratos à Vista — Imutabilidade, Programação Defensiva e JSpecify
46. Do JAR ao Executável — jlink, jpackage e GraalVM Native Image

Fase 9: O projeto final (47 a 52). Um servidor HTTP construído do zero, sem nenhuma biblioteca externa: sockets, leitura do protocolo à mão, records e sealed types para modelar requisições e respostas, virtual threads para atender milhares de conexões, arquivos servidos com NIO, testes e empacotamento. Cada fase anterior entra como uma pedra da construção. Termina com a retrospectiva do ano.

47. O Projeto Final Começa — Arquitetando um Servidor HTTP sobre Sockets
48. A Primeira Pedra — ServerSocket e a Leitura do HTTP/1.1
49. A Segunda Pedra — Requisições e Respostas como Tipos: Records, Sealed e Rotas
50. A Terceira Pedra — Mil Conexões ao Mesmo Tempo: Virtual Threads e Keep-Alive
51. A Pedra de Acabamento — Arquivos Estáticos, Testes e Empacotamento
52. A Jornada Completa — Retrospectiva de Um Ano de Java

Trilha de extensão A: Web, API e bancos de dados (53 a 66). Depois de construir um servidor à mão, você vai entender de verdade o que os frameworks fazem por você. Esta trilha tem um projeto próprio, as Trilhas da Ilha, um catálogo de trilhas de caminhada. Ele passa por SQLite, PostgreSQL, MySQL e MongoDB, vira uma API REST com autenticação e termina como um site completo, publicado num servidor.

53. Extensão — Java no Servidor: Servlets, Jakarta EE, Spring e Quarkus
54. Extensão — Dados que Sobrevivem: SQL Essencial e JDBC com SQLite
55. Extensão — Spring Boot pela Primeira Vez: Injeção de Dependência
56. Extensão — Objetos no Banco: JPA e Hibernate
57. Extensão — O Banco que Evolui: Spring Data e Migrations com Flyway
58. Extensão — PostgreSQL: o Banco Servidor, JSONB e Arrays
59. Extensão — MySQL: Driver, Dialeto e as Diferenças que Importam
60. Extensão — MongoDB: Documentos, Agregações e Quando Escolher Cada Modelo
61. Extensão — A API das Trilhas: REST, Validação, Erros e OpenAPI
62. Extensão — Quem É Você? Spring Security e JWT
63. Extensão — Bancos de Verdade nos Testes: Testcontainers
64. Extensão — Páginas Dinâmicas: Thymeleaf e Formulários
65. Extensão — O Site Completo: htmx, Login, Área Administrativa e Upload
66. Extensão — Do Laptop ao Servidor: Docker, nginx e Deploy

Trilha de extensão B: Desktop e Android (67 a 70). Interfaces gráficas em Java, do Swing ao JavaFX, um aplicativo de desktop que consome a API das Trilhas e uma introdução honesta ao Android, onde o Java divide espaço com o Kotlin.

67. Extensão — Janelas em Java: AWT, Swing e JavaFX
68. Extensão — JavaFX: Cenas, Controles e FXML
69. Extensão — Um App Desktop que Consome a API (MVVM)
70. Extensão — Java no Android: o que Mudou com o Kotlin e um App que Consome a API

Trilha de extensão C: Jogos com libGDX (71 a 77). O que torna um jogo diferente de qualquer outro programa: o game loop. Um primeiro jogo de naves, física com Box2D, mapas de blocos e um jogo de plataforma completo, com atenção especial a não produzir lixo dentro do loop, uma lição que vem direto da Fase 6.

71. Um Novo Território — Java nos Jogos, o Game Loop e o Caso Minecraft
72. O Primeiro Sprite — Janela, Desenho e Input com libGDX
73. Quando as Coisas se Tocam — Colisão e o Primeiro Jogo: Asteroids
74. Gravidade de Verdade — Física com Box2D
75. Mundos em Blocos — Mapas de Tiles e um Jogo de Plataforma
76. Sem Lixo no Loop — Pools, ECS e o Coletor nos Jogos
77. O Capstone dos Jogos — o Plataforma Completo e Exportado

O encerramento (78). O Destino e o Novo Começo — Encerrando a Jornada Completa. Um olhar sobre tudo o que foi construído, núcleo e trilhas, e os caminhos que se abrem depois de um ano de Java.

Uma palavra sobre o percurso

As fases não têm o mesmo peso. A Fase 1 vai parecer fácil para quem já programou, e é bom que pareça: ela cria a base de vocabulário. A Fase 2 é onde o Java começa a ser Java, e vale a pena ir devagar nela. As Fases 6 e 7 são as mais exigentes do curso. Elas tratam do que acontece por baixo do código e de programas que fazem várias coisas ao mesmo tempo, e muita gente trabalha anos com Java sem nunca entender esses assuntos direito. Não pule nenhuma delas. O servidor da Fase 9 depende de cada uma.

As trilhas de extensão podem ser feitas na ordem que você quiser depois do núcleo. A trilha A é a mais próxima do mercado de trabalho. A trilha C é a mais divertida. A trilha B depende da API construída na trilha A.

Como estudar cada aula

Setenta e oito aulas em um ano dão cerca de uma aula e meia por semana. É um ritmo confortável para quem estuda algumas horas por semana, mas o ritmo certo é o que você sustenta sem pular os exercícios. Constância vale mais que velocidade.

Três hábitos fazem diferença. Primeiro, digite o código em vez de copiar e colar: os erros de digitação e as mensagens do compilador ensinam tanto quanto o texto. Segundo, quebre o código de propósito: apague uma linha, troque um tipo e leia o que o compilador responde. Terceiro, mantenha uma pasta por aula (aula-01, aula-02...), porque os exemplos antigos vão reaparecer e você vai querer revê-los.

Você não precisa instalar nada hoje. A instalação é o tema de "Do Código ao Bytecode". Basta ter um computador com Windows, macOS ou Linux.

Fontes e leituras recomendadas

• Dev.java — Learn Java: https://dev.java/learn/. É o portal oficial de aprendizado mantido pela equipe do Java na Oracle, com tutoriais atualizados para as versões modernas da linguagem.
• Documentação da API do Java SE 25: https://docs.oracle.com/en/java/javase/25/docs/api/. É a referência de todas as classes da biblioteca padrão e será consultada em quase toda aula.
• Joshua Bloch, Effective Java, 3ª edição (Addison-Wesley, 2018): o livro mais respeitado sobre como escrever Java bom. Não é para iniciantes, mas vale ter por perto a partir da Fase 2.
• OpenJDK — JEPs: https://openjdk.org/jeps/0. Todas as mudanças na plataforma são propostas e discutidas em público como JEPs (JDK Enhancement Proposals). É onde você acompanha a linguagem sendo desenhada.
• Inside.java: https://inside.java/. Notícias, artigos e podcasts escritos pelas pessoas que desenvolvem o Java.

Exercícios

Exercício 1

Crie a pasta onde você vai guardar o curso inteiro e, dentro dela, as subpastas das três primeiras aulas. Anote o caminho completo.

Exercício 2

Das nove fases e três trilhas do mapa, escolha a que mais te atrai e a que mais te intimida. Escreva uma frase sobre cada uma.

Exercício 3

Calcule quantas aulas por semana você precisa fazer para concluir o núcleo (aulas 01 a 52) em 12 meses e em 6 meses, e o curso inteiro (01 a 78) nos mesmos prazos.

Exercício 4

O projeto final do núcleo é um servidor HTTP. Sem pesquisar, descreva com suas palavras o que acontece quando você digita um endereço no navegador e aperta Enter. Guarde a resposta.

Exercício 5

Pesquise e anote um sistema, jogo ou serviço que você usa no dia a dia e que foi feito, ao menos em parte, em Java.