Java Essencial: IDE e fluxo de trabalho com projetos Java simples

O que uma IDE faz no fluxo de trabalho Java

Uma IDE (Ambiente de Desenvolvimento Integrado) centraliza tarefas comuns do dia a dia: editar código com assistência (autocompletar, navegação), compilar e executar, depurar com ferramentas visuais, organizar arquivos do projeto e gerenciar configurações do JDK. Em projetos Java simples (sem Maven/Gradle), a IDE também ajuda a manter uma estrutura mínima consistente e a executar o programa sem você precisar digitar comandos no terminal a cada mudança.

Configurações essenciais da IDE (uma vez por máquina)

1) Selecionar o SDK/JDK do projeto

Mesmo com o JDK instalado, a IDE precisa saber qual JDK usar para compilar e executar. Isso evita erros como “language level” incompatível ou execução com uma versão diferente da esperada.

• Defina o JDK global (para novos projetos): procure por configurações do tipo SDKs, Java, Build Tools ou Installed JDKs e aponte para a pasta do JDK.
• Defina o JDK do projeto: em configurações do projeto, selecione o JDK e o language level (ex.: 17). Isso controla recursos de linguagem e compatibilidade de compilação.

2) Encoding UTF-8

Padronizar UTF-8 evita caracteres “quebrados” em strings, comentários e arquivos de recursos. Também reduz problemas ao compartilhar o projeto com outras pessoas.

• Configure o encoding global da IDE para UTF-8.
• Configure o encoding do projeto para UTF-8.
• Se existir opção de “default encoding for properties files”, também selecione UTF-8.

3) Formatação e estilo de código

Formatação consistente melhora leitura e reduz ruído em diffs. O ideal é usar o formatador da IDE e um conjunto de regras simples.

• Ative “format on save” (se disponível) ou acostume-se a usar o atalho de formatar.
• Defina indentação (comum: 4 espaços) e chaves no estilo padrão do Java.
• Ative organização de imports (remover imports não usados e ordenar).

4) Execução (Run) e Depuração (Debug)

Na IDE, “Run” executa o programa normalmente. “Debug” executa com um depurador acoplado, permitindo pausar em breakpoints e inspecionar o estado do programa.

Continue em nosso aplicativo e ...

• Ouça o áudio com a tela desligada
• Ganhe Certificado após a conclusão
• + de 5000 cursos para você explorar!

ou continue lendo abaixo...

Baixar o aplicativo

• Verifique onde a IDE define a classe principal (main class) e o working directory.
• Aprenda a diferença entre Run e Debug e onde ficam os botões/atalhos.
• Localize a janela/painel de Variables, Watches e Call Stack.

Criando um projeto Java simples (sem build tool)

Estrutura mínima de pastas

Sem Maven/Gradle, você pode manter uma estrutura enxuta. Uma opção simples e clara:

meu-projeto-java-simples/  src/    app/      Main.java  out/ (gerado pela IDE/compilação)

src contém o código-fonte. O diretório out (ou similar) costuma ser gerado pela IDE para os .class compilados. Você não precisa criar out manualmente.

Passo a passo na IDE (genérico)

• Crie um novo projeto do tipo Java (sem selecionar Maven/Gradle).
• Selecione o JDK do projeto (ex.: 17).
• Crie a pasta src e marque-a como Sources Root (se a IDE exigir).
• Crie um pacote (ex.: app) dentro de src.
• Crie a classe Main com o método public static void main(String[] args).

Exemplo de programa de console

Este exemplo lê um nome e uma idade, calcula o ano de nascimento aproximado e imprime mensagens. Ele é bom para praticar breakpoints, inspeção de variáveis e fluxo condicional.

package app; import java.util.Scanner; public class Main {     public static void main(String[] args) {         Scanner sc = new Scanner(System.in);         System.out.print("Digite seu nome: ");         String nome = sc.nextLine();         System.out.print("Digite sua idade: ");         int idade = Integer.parseInt(sc.nextLine());         int anoAtual = 2026;         int anoNascimento = anoAtual - idade;         String categoria;         if (idade < 12) {             categoria = "crianca";         } else if (idade < 18) {             categoria = "adolescente";         } else {             categoria = "adulto";         }         System.out.println("Ola, " + nome + "!");         System.out.println("Categoria: " + categoria);         System.out.println("Ano de nascimento (aprox.): " + anoNascimento);         sc.close();     } }

Como executar o projeto pela IDE

Run (execução normal)

• Abra a classe Main.
• Use a ação de executar na classe (geralmente um ícone ao lado do main) ou crie uma configuração de execução (Run Configuration).
• Confirme que a Main class é app.Main.
• Execute e observe a saída no console da IDE.

Erros comuns ao executar (e como identificar)

Depuração na prática: breakpoints e navegação

Conceitos essenciais

• Breakpoint: marca uma linha onde a execução vai pausar no modo debug.
• Step Over: executa a linha atual e vai para a próxima linha no mesmo método (não “entra” em métodos chamados).
• Step Into: entra no método chamado na linha atual (útil para ver o que acontece dentro).
• Step Out: executa até sair do método atual e volta ao chamador.
• Resume: continua a execução até o próximo breakpoint ou até o fim.
• Variables: painel para ver valores das variáveis no ponto atual.
• Watches: expressões que você quer acompanhar (ex.: anoNascimento, nome.length()).
• Call Stack: pilha de chamadas; mostra por onde o programa passou para chegar no ponto atual.

Onde colocar breakpoints (sugestão)

No exemplo, bons pontos para pausar:

• Na linha que faz int idade = Integer.parseInt(...) (para verificar entrada).
• Na linha int anoNascimento = anoAtual - idade; (para conferir cálculo).
• Na primeira linha dentro de cada ramo do if (para ver qual caminho foi escolhido).

Exercício guiado (hands-on): criar e depurar um programa de console

Objetivo

Criar um projeto Java simples sem build tool, executar em modo normal e depois executar em modo debug usando breakpoints, step over/into e inspeção de variáveis.

Parte A — Criar o projeto e o código

• Crie um projeto Java simples (sem Maven/Gradle).
• Configure o JDK do projeto e encoding UTF-8.
• Crie src e o pacote app.
• Crie a classe Main e cole o código do exemplo.
• Formate o arquivo usando o formatador da IDE.

Parte B — Executar (Run)

• Execute em modo Run.
• Quando solicitado, digite um nome e uma idade (ex.: Ana e 16).
• Confirme no console a categoria e o ano de nascimento aproximado.

Parte C — Depurar (Debug) com breakpoints

• Adicione um breakpoint na linha do Integer.parseInt.
• Inicie em modo Debug.
• Quando parar no breakpoint, observe no painel de variáveis os valores atuais (por exemplo, nome já deve estar preenchido, e idade ainda não).
• Use Step Over para executar a linha e veja idade aparecer com valor.
• Adicione um breakpoint na linha int anoNascimento = anoAtual - idade; e use Resume para ir até ele.
• Com o programa pausado, adicione um Watch para anoAtual - idade e compare com anoNascimento após executar a linha (Step Over).

Parte D — Explorar Step Into e inspeção

• Coloque um breakpoint na linha System.out.println("Ola, " + nome + "!");.
• Ao parar, use Step Into (se a IDE permitir entrar em chamadas) e observe a pilha de chamadas. Em muitas IDEs, você pode configurar para não entrar em código da biblioteca padrão; se entrar, use Step Out para voltar.
• No painel de variáveis, expanda objetos quando possível (por exemplo, o Scanner) e observe campos internos (apenas para familiaridade; não é necessário entender todos).

Parte E — Desafio rápido (ajuste e valide no debug)

• Altere anoAtual para usar o ano do sistema com a API de data/hora.
• Dica: use java.time para obter o ano atual.

// Substitua: int anoAtual = 2026; // Por algo como: // int anoAtual = java.time.Year.now().getValue();

• Execute em Debug e confirme no painel de variáveis que anoAtual corresponde ao ano atual.