Aulas

Vamos entender o que é o arquivo module-info.java, onde ele fica no projeto e como declarar um módulo com a palavra‑chave module. Aprendemos a exportar a API com exports, a declarar dependências com requires e também vemos diretivas adicionais ( opens, uses, provides ... with). Nesta aula — exemplos, regras de nomenclatura de módulos, análise prática da estrutura do projeto e erros típicos na montagem modular.

Como o Java 9+ adicionou encapsulamento modular por cima de classes e pacotes: até classes public ficam ocultas enquanto o pacote não for explicitamente aberto via exports em module-info.java. Vamos ver como declarar dependências com requires, como restringir visibilidade com exports to, em que o nível module difere de private/ public, e quais erros de compilação (por exemplo, “package ... is not visible”, “cannot access ...”) indicam que você esqueceu um exports ou requires.

Guia prático sobre arquitetura modular em Java: quando e por que dividir o código em módulos, esquemas típicos (arquitetura “Onion”, separação em api/ impl, módulos de testes), configuração de dependências via module-info.java e palavras‑chave requires/ exports, exemplos práticos de um projeto com 3 módulos, integração com Maven/ Gradle e IntelliJ IDEA, além da análise de erros comuns (dependências cíclicas, pacotes não exportados, --module-path incorreto).

Como construir um projeto modular em Java: diferença entre classpath e module-path, quando usar a flag --module-path, como configurar uma estrutura multimódulo no Maven e no Gradle, e como executar tudo a partir do IntelliJ IDEA. Mostraremos a estrutura de módulos com module-info.java, dependências via requires/ exports, configuração de plugins e erros frequentes durante o build.

Vamos entender como executar comandos e utilitários externos a partir do Java usando a classe ProcessBuilder: por que ela é melhor que Runtime. getRuntime(). exec(), como configurar o diretório de trabalho com directory(), variáveis de ambiente com environment() e gerenciar o processo com start(), waitFor(), streams getInputStream()/ getErrorStream()/ getOutputStream(). Vamos discutir multiplataforma ( cmd.exe/ ls), o trabalho com stdout/ stderr e erros comuns.

Prática com processos externos em Java: como ler stdout via Process.getInputStream(), capturar erros de stderr via Process.getErrorStream(), escrever em stdin usando Process.getOutputStream() e também usar os métodos convenientes inputReader()/ errorReader()/ outputWriter(). Vamos analisar particularidades de comandos como java -version, a leitura paralela dos fluxos para evitar deadlock, o trabalho com codificações ( "UTF-8") e uma pequena ponte com scripts Python.

Prática de gerenciamento de processos externos a partir do Java: aguardamos a finalização com waitFor() (incluindo timeouts), lemos o código de saída, encerramos corretamente com destroy()/ destroyForcibly(), evitamos travamentos e processos zumbi, sem esquecer os fluxos de saída e as exceções. Abordamos nuances multiplataforma e erros típicos.

Nesta aula, veremos como, a partir do Java, organizar um diálogo “ao vivo” com programas externos: escrever em stdin, ler de stdout e stderr, evitar bloqueios mútuos ( deadlock), processar a saída em paralelo com ExecutorService, fechar fluxos corretamente e gerenciar o ciclo de vida de Process por meio de ProcessBuilder. Veremos exemplos com um script interativo em Python e com o utilitário bc, além de analisar as armadilhas da bufferização e a necessidade de flush().

Guia prático para trabalhar de forma robusta com processos externos em Java: como evitar travamentos por causa de fluxos não lidos stdout/ stderr, configurar corretamente as codificações de saída (por exemplo, UTF-8, CP866), levar em conta diferenças multiplataforma de comandos ( ls vs dir), tratar permissões e códigos de saída via process.exitValue(), fechar recursos sem vazamentos e evitar bloqueios mútuos em interações interativas. Abordamos o uso adequado de ProcessBuilder, a leitura paralela dos fluxos (threads/ ExecutorService), o encerramento apropriado via process.destroy(), bem como caminhos portáveis com File.separator.

Vamos entender o que é reflexão em Java e por que ela é necessária para frameworks e ferramentas, como funciona o objeto Class — o coração da reflexão — e as maneiras de obtê‑lo: via .class, getClass() e Class.forName(). Falaremos quando vale a pena aplicar reflexão e quando é melhor evitá‑la, veremos exemplos de obtenção de metadados (nome, pacote, superclasse, interfaces), analisaremos uma mini‑utilidade “Que classe é esta?” e erros típicos ( ClassNotFoundException, desempenho, segurança).

Nesta aula abordamos reflexão em Java: como, por meio da Class-API, obter informações sobre campos ( getFields()/ getDeclaredFields()), métodos ( getMethods()/ getDeclaredMethods()), construtores ( getConstructors()/ getDeclaredConstructors()) e anotações ( getAnnotations()). Veremos os modificadores via Modifier ( public, private, protected, static, final), entenderemos as diferenças “public vs declared”, construiremos uma miniutilidade de inspetor de classes e veremos um esquema visual.

Nesta aula, analisamos os riscos e as limitações da reflexão: burlar a encapsulação via setAccessible( true), tentar alterar campos final e por que isso é perigoso devido às otimizações da JVM; o destino do SecurityManager e como o sistema de módulos (Java 9+) leva a InaccessibleObjectException. Falaremos sobre perda de desempenho e de segurança de tipos, alternativas modernas ( record, sealed, pattern matching, APT, DI) e boas práticas. No fim — um exemplo prático com o parâmetro da JVM --add-opens.