2. Configuração do ambiente de desenvolvimento
O ambiente de trabalho do desenvolvedor Java é composto por três componentes independentes:
- o JDK (“Java Development Kit”): o compilador [javac], a máquina virtual e o comando [java] que executa os programas, as bibliotecas padrão do Java SE e ferramentas como [jshell] ou [jar];
- uma ferramenta de build de projetos, no caso o Maven: ela baixa as bibliotecas de que um projeto precisa, compila-o, executa seus testes e o empacota;
- um editor ou uma IDE (Integrated Development Environment): [IntelliJ IDEA], [VS Code] com extensões Java ou [Eclipse]. A IDE se apoia no JDK e sabe ler projetos Maven.
Este documento usa os comandos [java], [javac] e [mvn] para todas as operações: eles funcionam da mesma forma no Windows, no Linux e no macOS, qualquer que seja o editor escolhido.
2.1. JDK 25
2.1.1. Instalação
Existem várias distribuições do JDK, todas construídas a partir do código-fonte do OpenJDK e equivalentes para nossos propósitos. Recomendamos o Eclipse Temurin, uma distribuição gratuita e de código aberto da Eclipse Foundation, que pode ser baixada em https://adoptium.net: ali, selecione a versão 25—LTS, o sistema operacional e o tipo de pacote (no Windows, um instalador [.msi]). No Windows, também é possível instalá-lo a partir de um terminal (PowerShell ou prompt de comando) com o gerenciador de pacotes [winget]:
É preciso selecionar o JDK (que contém tudo) e não apenas o JRE (que só permite executar programas já compilados). Na instalação no Windows, marque as opções que adicionam o JDK ao [PATH] e definem a variável de ambiente [JAVA_HOME]: o Maven e as IDEs a usam para localizar o JDK. No Linux, o JDK está disponível nos repositórios das principais distribuições (por exemplo, [sudo apt install openjdk-25-jdk] no Ubuntu).
Após a instalação, abra um novo terminal para verificar se os comandos [java] e [javac] estão disponíveis e exibem a versão do JDK:
Esses resultados foram obtidos com o pacote do JDK do Ubuntu. Com o Temurin, as linhas 2 e 3 listam [Temurin-25], e a versão exata depende da data de instalação: as atualizações de correção são lançadas a cada trimestre. Todas as versões 25.0.x do JDK servem para este documento. Vários JDKs podem coexistir no mesmo sistema: o primeiro encontrado no [PATH] responde ao comando [java].
2.1.2. Os comandos do JDK
O JDK oferece numerosos comandos. Estes são os que usaremos:
Comando | Função |
[java File.java] | compila em memória e executa um programa escrito em um arquivo-fonte (Java 11; vários arquivos a partir do Java 22) |
[javac -d classes File.java] | compila um ou mais arquivos-fonte e coloca os arquivos [.class] resultantes na pasta [classes] |
[java -cp classes ClassName] | executa o método [main] de uma classe compilada, procurada no class path ([-cp]) |
[java -cp "lib/*" File.java] | executa um arquivo-fonte que usa as bibliotecas (arquivos [.jar]) da pasta [lib] |
[jshell] | Interpretador interativo: você digita instruções Java e vê os resultados imediatamente |
[jar] | cria ou lê um arquivo [.jar] (um arquivo ZIP de classes compiladas) |
O interpretador [jshell] (Java 9) é útil para testar um método ou uma expressão sem escrever um programa:
2.2. Maven
2.2.1. Instalação
Uma aplicação Java real usa bibliotecas que não fazem parte do JDK: um driver de banco de dados, um framework de testes, o Hibernate, o Spring… Elas são distribuídas como arquivos [.jar] por meio de um repositório público, o Maven Central (https://central.sonatype.com). Uma ferramenta de build como o Maven lê o arquivo [pom.xml] de um projeto para determinar de quais bibliotecas ele precisa, baixa-as (junto com as bibliotecas das quais elas dependem) e então compila, testa e empacota o projeto. Outra ferramenta muito usada, o Gradle, cumpre a mesma função; este documento usa o Maven.
O Maven pode ser baixado em https://maven.apache.org/download.cgi como um arquivo ZIP ([apache-maven-3.9.x-bin.zip]). Descompacte-o em uma pasta, por exemplo [C:\Program Files\apache-maven-3.9.11], e adicione a subpasta [bin] ao [PATH] (Windows: “Editar as variáveis de ambiente do sistema”). No Linux, o Maven está disponível nos repositórios da distribuição ([sudo apt install maven]). Verifique a instalação em um novo terminal:
A linha 4 é importante: ela mostra o JDK usado pelo Maven, que é referenciado pela variável [JAVA_HOME]. Ele deve ser um JDK 25. As IDEs IntelliJ IDEA e VS Code incluem seu próprio Maven: ele basta se você não usa o Maven pela linha de comando.
As bibliotecas baixadas pelo Maven são armazenadas na máquina local, no repositório local [%USERPROFILE%\.m2\repository] (Linux, macOS: [~/.m2/repository]). Elas são baixadas uma única vez e depois usadas por todos os projetos. Por isso, é necessária uma conexão com a Internet ao construir um projeto pela primeira vez.
2.2.2. Comandos do Maven
O comando [mvn] é seguido de uma ou mais fases do ciclo de build, ou de um goal de plugin; ele é digitado na pasta que contém o arquivo [pom.xml]:
Comando | Função |
[mvn compile] | compila o código-fonte de [src/main/java]; as classes são organizadas em [target/classes] |
[mvn test] | compila e depois executa os testes unitários de [src/test/java] (Capítulo 6) |
[mvn package] | compila, testa e cria o arquivo [.jar] do projeto em [target] |
[mvn install] | como [package], e depois copia o arquivo para o repositório local, onde outros projetos podem usá-lo (Capítulo 6) |
[mvn clean] | exclui a pasta [target] |
[mvn compile exec:java] | compila e depois executa a classe principal do projeto (plugin [exec-maven-plugin]) |
[mvn spring-boot:run] | executa uma aplicação Spring Boot (Capítulo 13) |
As fases são sequenciais: executar [package] também aciona [compile] e [test]. A opção [-q] (“quiet”) suprime as mensagens do Maven e exibe apenas as do programa executado; a opção [-Dexec.args="a b"] passa argumentos ao programa iniciado por [exec:java].
2.3. O editor
2.3.1. IntelliJ IDEA
IntelliJ IDEA, da empresa JetBrains, é o editor Java mais usado. Seus recursos básicos, mais que suficientes para este documento, são gratuitos. Ele oferece suporte a projetos Maven: selecione “File / Open” e escolha a pasta que contém o arquivo [pom.xml]; o IntelliJ baixa as bibliotecas, compila o projeto e permite executar uma classe clicando no triângulo verde na margem ao lado de seu método [main] ([Ctrl-Shift-F10]), ou executar um teste clicando no mesmo triângulo ao lado do método de teste. Indique o JDK a usar em “File / Project Structure / SDK”.
Você pode abrir de uma só vez toda a pasta de exemplos [java-oct-2026] (“File / Open”): o IntelliJ detecta ali todos os projetos Maven e os exibe em seu painel “Maven”. Uma precaução é necessária neste ponto. Os projetos dos Capítulos 10 a 13 (versões 6 a 9 da [aplicação Tax]) usam os módulos [tax-dao], [tax-business] e [tax-ui] da versão 5, escrita no Capítulo 6. Eles não são bibliotecas públicas: o Maven só consegue encontrá-los no repositório local se tiverem sido instalados ali. Portanto, é preciso começar instalando a versão 5: no painel “Maven”, expanda [tax-v5] / "Lifecycle" e dê um duplo clique em [install] (ou digite [mvn install] na pasta [06-architectures/TaxV5]), depois clique no botão "Sync All Maven Projects" do painel. O Capítulo 6 explica o que esse comando faz e o que fazer se o IntelliJ ainda indicar dependências não resolvidas.
2.3.2. VS Code
VS Code é um editor gratuito e multiplataforma. Para programar em Java, você pode instalar o Extension Pack for Java da Microsoft (acesse o menu “Extensions” e procure por “Extension Pack for Java”), que inclui suporte à linguagem, depurador, execução de testes e suporte ao Maven. Ele oferece:
- realce de sintaxe, autocompletar código e ajuda em dicas contextuais;
- detecção de erros durante a digitação;
- navegação no código (F12: ir para a definição);
- execução e depuração (os links “Run” e “Debug” acima de cada método [main] ou F5);
- execução de testes unitários (a visão “Testing”) e uma visão “Maven” dos projetos.
No VS Code, abra a pasta que contém os programas (“File / Open Folder”), por exemplo, a pasta [java-oct-2026] com os exemplos deste documento. O terminal integrado (“Terminal / New Terminal”) permite digitar os comandos [java] e [mvn] sem sair do editor.
2.3.3. Eclipse
Uma terceira opção é a IDE de código aberto Eclipse (https://eclipseide.org), historicamente a primeira grande IDE Java, que também importa projetos Maven (“File / Import / Maven / Existing Maven Projects”).
No restante deste documento, as operações são descritas com os comandos [java], [javac] e [mvn], que produzem os mesmos resultados qualquer que seja o editor.
2.4. Um primeiro programa: um arquivo-fonte compacto
2.4.1. O programa
A partir do Java 25, um programa Java pode ser um simples arquivo contendo um único método [main], sem declaração de classe. Isso é chamado de “arquivo-fonte compacto”. Vamos criar o seguinte arquivo [Hello.java]:
e executá-lo:
Comentários:
- linha 1: um comentário. Tudo o que segue [//] até o fim da linha é ignorado pelo compilador;
- linha 2: o método [main], ponto de entrada do programa. Em um arquivo-fonte compacto, ele não precisa ser declarado em uma classe, nem ser [public] e [static], nem receber os argumentos do programa; veremos no Capítulo 3 que o próprio compilador o envolve em uma classe;
- linha 3: a única instrução do programa: ela escreve uma linha de texto na tela. A classe [IO] (Java 25) oferece métodos simples para escrever ([print], [println]) e para ler ([readln]) do teclado;
- o comando [java Hello.java] compila o programa em memória, sem criar um arquivo [.class], e depois o executa. Essa capacidade de executar diretamente um arquivo-fonte foi introduzida no Java 11.
O nome do arquivo deve ser um identificador Java válido: [Hello.java] ou [Basics01.java] são aceitáveis, mas [basics-01.java] é rejeitado pelo compilador ([bad file name]), pois o nome do arquivo se torna o nome da classe gerada. Por convenção, os nomes de classes, e portanto os nomes de arquivos, começam com letra maiúscula.
Também é possível compilar o programa com o [javac], que produz um arquivo [.class], e depois executar esse arquivo compilado:
O arquivo [Hello.class] contém o bytecode da classe [Hello] gerada pelo compilador. O comando [java -cp classes Hello] instrui a máquina virtual a executar o método [main] da classe [Hello], que está na pasta [classes].
Os arquivos-fonte compactos são adequados a programas pequenos, e os usaremos na maioria dos exemplos. Quando um programa exige uma biblioteca externa, ainda é possível iniciá-lo com o comando [java -cp "lib/*" Program.java] se você tiver copiado os arquivos [.jar] da biblioteca (e dos que ela utiliza) para uma pasta [lib]. Mas reunir esses arquivos manualmente logo se torna cansativo, então escreveremos um projeto Maven.
No Windows, os caracteres acentuados escritos por [IO.println] ou por [System.out.println] aparecem corretamente no terminal: o Java converte o texto para a codificação do terminal. Os arquivos-fonte devem ser salvos em UTF-8, a codificação padrão do VS Code e do IntelliJ IDEA e a que o compilador assume a partir do Java 18.
2.5. Um projeto Maven
2.5.1. Estrutura do projeto
Um projeto Maven é uma pasta que contém um arquivo [pom.xml] (“Project Object Model”) e arquivos-fonte organizados segundo uma estrutura de diretórios padrão. O projeto [FirstProgram] da pasta [02-installation] é o seguinte:
- [src/main/java] contém os arquivos-fonte do programa; [src/main/resources] contém os arquivos de dados ou de configuração a serem colocados junto das classes compiladas; [src/test/java] contém os testes (Capítulo 6);
- Sob [src/main/java], a estrutura de pastas reflete a dos pacotes (Capítulo 4): a classe [first.Main] está na pasta [first].
Você pode criar essa estrutura de diretórios manualmente ou deixar a IDE criá-la (IntelliJ: “File / New / Project”, selecionando “Maven” como sistema de build). O arquivo [pom.xml] é o seguinte:
- linhas 8 a 10: as coordenadas do projeto, que o identificam de maneira única: o grupo ([groupId], frequentemente um nome de domínio invertido como [org.hibernate]), o nome do projeto ([artifactId]) e sua versão. São também os identificadores que outro projeto usará para referenciar este, se necessário, da mesma forma que se referencia uma biblioteca do Maven Central (Capítulo 6);
- linha 14: o código é compilado para o Java 25;
- linha 15: os arquivos-fonte são escritos em UTF-8;
- linhas 21 a 30: o plugin de compilação, com a opção [-Xlint:all], que ativa todos os avisos do compilador;
- linhas 32 a 39: o plugin [exec-maven-plugin], que permite executar a classe principal do projeto, indicada na linha 37, com o comando [mvn exec:java].
Este projeto não usa nenhuma biblioteca. Um projeto que usa uma biblioteca a declara em uma seção [<dependencies>] por meio de suas coordenadas, como faremos a partir do Capítulo 5:
O arquivo [Main.java] contém o programa em sua forma padrão, com uma classe [public] e um método [public static void main(String[] args)]:
- linha 1: a classe pertence ao pacote [first]; seu nome completo é [first.Main];
- linhas 4 a 9: a classe [Main]. Um arquivo-fonte contém no máximo uma classe pública, que leva o nome do arquivo;
- linhas 6 a 8: o método [main], na forma que tem desde a primeira versão do Java. Compararemos as duas formas no Capítulo 3.
2.5.2. Compilação e execução
O comando [mvn compile], digitado na pasta do projeto, compila o projeto: o Maven baixa os plugins necessários, se for o caso, depois compila os arquivos de [src/main/java] e coloca as classes resultantes na pasta [target/classes], preservando a hierarquia de pacotes ([target/classes/first/Main.class]). O comando [mvn compile exec:java] compila o projeto e depois o executa; com a opção [-q], apenas a saída do programa é exibida:
Depois que o projeto está compilado, também é possível executar a classe diretamente com o comando [java], indicando a localização das classes:
A pasta [target] pode ser excluída sem risco ([mvn clean]): ela será recriada na próxima compilação. O comando [mvn package] também produz o arquivo [target/first-program-1.0.jar], que pode ser executado com [java -cp target/first-program-1.0.jar first.Main]: é o formato em que um programa Java é entregue.
2.6. Um projeto com vários módulos
2.6.1. O projeto agregador
Um projeto Maven pode agrupar vários outros projetos, chamados de seus módulos. A pasta [02-installation] contém um arquivo chamado [pom.xml] que agrupa seus dois projetos:
- linha 11: este projeto não produz um arquivo [.jar]: ele serve apenas para agrupar outros projetos ([pom]);
- linhas 13 a 16: os módulos, identificados pelos nomes de suas pastas.
Na pasta [02-installation], o comando [mvn compile] compila os dois projetos; uma IDE que abre essa pasta vê os dois projetos de uma só vez. No Capítulo 6, veremos que um projeto pai também pode repassar uma configuração comum (versões de bibliotecas, opções do compilador) a seus módulos.
2.6.2. Um projeto com vários métodos main
Um projeto pode conter várias classes, cada uma com um método [main] : cada uma é um possível ponto de entrada, e a classe a executar é escolhida em tempo de execução. O projeto [TwoHands] contém duas classes. A classe [P1]:
e a classe [P2], idêntica, exceto pelo nome. O comando [java] executa a classe indicada:
Para o comando [mvn exec:java], o arquivo de projeto [pom.xml] especifica a classe a executar:
- linha 7: o método [main] executado pertence à classe [twohands.P2] (o nome completo da classe, incluindo o pacote).
Resultados:
Você pode escolher outra classe sem modificar o arquivo [pom.xml]: [mvn -q exec:java -Dexec.mainClass=twohands.P1].
2.7. Os exemplos do documento
Para executar os exemplos deste documento:
- baixe a pasta [java-oct-2026] (link no início do documento);
- abra-a no VS Code (“File / Open Folder”) ou, para um projeto Maven específico, abra sua pasta no IntelliJ IDEA;
- em um terminal posicionado na pasta de um capítulo, execute um arquivo-fonte compacto com [java Name.java], ou um projeto Maven com [mvn -q compile exec:java] na pasta do projeto (o texto de cada capítulo indica o comando exato).
Os Capítulos 10 e 11 usam um banco de dados MySQL; a instalação do MySQL junto com o [Laragon] é descrita no apêndice.