Controle a ordem do programa com if, else, switch, while e for. Você pratica decisões, repetição e pequenos problemas como validação de entrada e contadores.

Separe código em métodos com parâmetros, retorno e nomes claros. Isso permite resolver problemas maiores sem deixar tudo dentro do main.

Use arrays, listas simples e percursos para lidar com muitos valores. Você cria pequenos programas que leem, transformam e exibem coleções de dados.

Veja como Java saiu dos applets e sistemas corporativos antigos para servidores, Android, nuvem e versões modernas da linguagem. A história ajuda a explicar a JVM, a compatibilidade, o ecossistema e por que Java ainda é tão usado.

Modele objetos com classes, campos, construtores e métodos. Você cria entidades reais do domínio, como Conta, Produto e Pedido, e decide onde cada comportamento pertence.

Use encapsulamento, modificadores de acesso e invariantes para proteger o estado dos objetos. Você pratica classes que continuam válidas mesmo quando outras partes do programa tentam usá-las errado.

Aplique herança, sobrescrita, classes abstratas e interfaces sem transformar o código em confusão. O capítulo mostra quando reutilizar comportamento e quando preferir contratos simples.

Organize arquivos em pacotes, use imports e monte projetos com uma estrutura limpa. Você passa de arquivos soltos para um projeto Java fácil de navegar.

Use List, Set, Map, Queue e suas implementações mais comuns. Você escolhe a coleção certa para busca, ordem, repetição, contagem e remoção de dados.

Use generics para criar listas, mapas e classes seguras sem conversões perigosas. Você também lida com tipos curinga quando uma API precisa aceitar variações.

Trate erros com exceções, try-catch, finally e try-with-resources. Você diferencia falhas esperadas, bugs e situações que precisam de mensagens úteis para o usuário ou para o log.

Leia e escreva arquivos com java.nio, streams de bytes e texto, caminhos e codificação. Você cria programas que salvam configurações, relatórios e dados simples.

Use LocalDate, LocalDateTime, Instant, Duration, Locale e formatação. Você evita erros comuns com fuso horário, datas de negócio e exibição para usuários brasileiros.

Use enums, anotações e reflection com cuidado. Você cria opções fechadas, marca comportamentos e vê como frameworks descobrem informações do seu código em tempo de execução.

Escreva funções anônimas com lambdas, use interfaces funcionais e simplifique callbacks. Esse estilo prepara o caminho para streams, APIs modernas e código mais expressivo.

Transforme, filtre, agrupe e reduza dados com a Stream API. Você pratica relatórios, somatórios, buscas e agrupamentos sem loops manuais desnecessários.

Escreva testes com JUnit, organize casos de teste e use assertions claras. Você ganha segurança para alterar código sem quebrar comportamentos importantes.

Use mocks, testes de integração e dados de teste para validar código que conversa com arquivos, bancos e serviços. O foco é testar colaboração entre partes sem depender de sorte.

Compile, rode testes, empacote e gerencie dependências com Maven e Gradle. Você lê arquivos pom.xml e build.gradle e sabe como uma biblioteca externa entra no projeto.

Use Git, branches, pull requests e mensagens de commit úteis em projetos Java. Você trabalha de forma segura em equipe e mantém histórico de mudanças compreensível.

Use breakpoints, inspeção de variáveis, stack traces e logs com SLF4J e Logback. Você encontra defeitos reais sem depender apenas de println.

Gere e leia Javadoc, use convenções de estilo e organize código para manutenção. Você deixa APIs internas mais fáceis de usar por outras pessoas e por você no futuro.

Veja como a JVM carrega classes, executa bytecode, usa heap e stack e aplica coleta de lixo. Isso ajuda a explicar desempenho, consumo de memória e erros como OutOfMemoryError.

Meça tempo, memória e gargalos com cuidado antes de otimizar. Você usa profiling, benchmarks com JMH e boas decisões sobre coleções, alocação e I/O.

Crie threads, use synchronized, locks e coleções concorrentes. Você pratica problemas clássicos de corrida, visibilidade e coordenação entre tarefas.

Use ExecutorService, CompletableFuture e tarefas assíncronas para trabalho paralelo mais controlado. Você compõe chamadas, trata falhas e evita criar threads sem limite.

Use virtual threads para escrever código concorrente simples e escalável em Java moderno. Você vê onde elas brilham, onde não substituem programação assíncrona e como afetam servidores.

Use sockets, HTTP clients, JSON e serialização para conversar com outros sistemas. Você cria clientes de API, trata códigos de status e transforma respostas em objetos Java.

Acesse bancos relacionais com JDBC, conexões, prepared statements e transações. Você grava e consulta dados sem abrir brechas de SQL injection nem perder consistência.

Use JPA e Hibernate para mapear objetos para tabelas quando isso vale a pena. Você lida com entidades, relacionamentos, consultas, lazy loading e problemas comuns de desempenho.

Crie APIs HTTP com Spring Boot, controllers, serviços, validação e tratamento de erros. Você monta um serviço simples que recebe requisições, aplica regras e devolve respostas JSON.

Proteja aplicações Java com autenticação, autorização, hashing de senhas, TLS e validação de entrada. O capítulo também cobre riscos comuns como injeção, vazamento de segredo e dependências vulneráveis.

Use records para carregar dados imutáveis com menos código repetido. Você aplica records em DTOs, resultados de consulta e valores simples, sabendo quando uma classe comum ainda é melhor.

Modele escolhas fechadas com sealed classes e use pattern matching para tratar casos com clareza. Você cria código mais seguro para resultados, eventos e hierarquias controladas.

Use o sistema de módulos do Java para declarar dependências e limites entre partes do sistema. Você vê onde JPMS ajuda, onde atrapalha e como ele aparece em bibliotecas e aplicações maiores.

Prepare aplicações Java para containers com imagens pequenas, configuração externa e limites de CPU e memória. Você ajusta a JVM para ambientes Docker e evita surpresas em produção.

Crie pipelines de CI/CD que compilam, testam, verificam qualidade e publicam artefatos. Você automatiza o caminho do commit até uma versão pronta para entrega.

Use SBOM, verificação de vulnerabilidades, assinaturas e atualização disciplinada de bibliotecas. Você reduz riscos quando o projeto depende de código de terceiros.

Acompanhe logs estruturados, métricas, traces e health checks em aplicações Java. Você identifica falhas em produção e cria sinais úteis para operação.

Use GraalVM e native images para reduzir tempo de inicialização e consumo em cenários específicos. Você avalia custos, limitações de reflection, compatibilidade de bibliotecas e ganhos reais.

Trabalhe com mensageria usando filas, tópicos, eventos e consumidores. Você usa padrões comuns com Kafka ou RabbitMQ e aprende a lidar com repetição, ordem, idempotência e falhas.

Use programação reativa quando muitas operações de I/O precisam fluir sem bloquear. Você pratica streams reativos, backpressure e os cuidados para não transformar o código em algo difícil de manter.

Mantenha sistemas Java antigos com segurança: versões antigas, servidores de aplicação, bibliotecas legadas e migrações graduais. Você aprende a melhorar código existente sem parar o negócio.

Siga uma demanda real desde a história do usuário até produção: desenho da API, modelagem, testes, banco, segurança, build, deploy e observabilidade. O capítulo junta as decisões que um time Java toma no dia a dia.

Use assistentes de IA para gerar rascunhos, testes e explicações sem entregar código que você não consegue defender. Você pratica revisão, checagem de segurança, leitura de APIs e proteção de dados sensíveis.

Conheça caminhos de atuação com Java: backend, Android legado, sistemas corporativos, dados, cloud, arquitetura e manutenção de plataformas críticas. Você monta portfólio, escolhe certificações quando fizerem sentido e cria rotina para acompanhar novas versões do Java e do ecossistema.