Fundamentos de Desenvolvimento com Java
Do JDK ao debugger: o básico que evita sofrimento
Você já ouviu falar em “sei Java” que trava no primeiro javac? Essas questões são justamente a vacina contra isso. Você vai começar pelo chão da fábrica (instalar JDK, configurar PATH, fazer a IDE obedecer) e terminar fazendo o que programador de verdade faz quando o mundo real aparece: ler entrada, lidar com tipo, quebrar o programa de propósito e consertar com método. Calma lá: não é glamour. É disciplina. E é isso que paga a conta. #SQN.
O primeiro desafio não é “orientação a objetos” nem “coleções”. É mais básico e mais cruel: fazer o ambiente parar de te sabotar. Você vai esbarrar em versão errada de Java, SDK apontando pra lugar diferente no terminal e na IDE, projeto que “roda” mas não faz build, e aquele clássico: “funciona aqui” até você trocar de máquina. Se você atravessar essa parte, você ganha uma skill rara: autonomia operacional. Você não depende de tutorialzinho mágico pra rodar um projeto.
Agora imagina que você entrou num estágio e alguém te passa um repositório com um HelloWorld que deveria compilar em 30 segundos. Você clona, abre no IntelliJ e... nada. Erro de JDK, classpath, run configuration, ou o build falha porque tem arquivo velho quebrado. Essas questões te treinam pra resolver isso sem drama: você aprende a enxergar o ciclo completo (editar -> compilar -> executar -> validar), e a diferenciar “rodar um arquivo” de “o projeto buildar de verdade”. Isso muda seu nível de jogo, porque build é o que vai pro CI, pro servidor, pro mundo.
Mais pra frente, o mundo real aparece com entrada do usuário e tipos. “Lê um nome e uma idade” parece bobo, até você misturar nextInt() com nextLine() e o programa “pula” uma leitura, ou até alguém digitar “abc” onde você esperava número e o negócio explode. Aqui você aprende duas qualidades que valem ouro: previsibilidade e robustez. Seu código não fica “sensível ao humor do usuário”.
E aí vem o trecho que separa “aprendi sintaxe” de “aprendi a programar”: depuração. Você vai introduzir erro, ler mensagem do compilador, interpretar stack trace, usar breakpoint, inspecionar variáveis e provar a correção. Debug é método: hipótese, evidência, ajuste mínimo, validação.
Se você conseguir resolver todas as questões, vai dominar um pacote concreto de competências:
- Montar e validar ambiente Java de forma reprodutível (JDK, PATH/JAVA_HOME, IDE alinhada com terminal).
- Navegar no pipeline do desenvolvimento: compilar, buildar, executar, reexecutar e confirmar resultado.
- Escrever Java básico com tipos, variáveis, strings e saída no console sem tropeçar em detalhe bobo.
- Ler entrada de usuário com segurança (e sem armadilhas clássicas), tratando erros previsíveis.
- Depurar com técnica: usar mensagens, stack trace, debugger e não superstição.
- Desenvolver hábitos de qualidade mínima: testar por execução controlada e validar com casos simples.
Se você consegue explicar por que o build falha, alinhar JDK da IDE com o do terminal, e usar debugger para provar que corrigiu o bug, entendeu. Se não, decorou.
1. Dominando o ambiente: diferença entre JRE e JDK, com foco em PATH e JAVA_HOME para evitar o terminal sem java/javac.
2. Ciclo de vida do código: classe + main, e diferença entre build/compilar (projeto inteiro) e executar/rodar (entrypoint).
3. Dados e interação: tipos int, double, String; concatenação; leitura via Scanner sem cair no bug do newline.
4. Depuração: separar erro de compilação, erro lógico e runtime, usando breakpoint, step over/into e inspeção de variáveis.
java -version e javac -version e ambos respondem com versão.Diagnóstico rápido: 90% dos problemas aqui são “instalei JRE achando que era JDK” ou “instalei, mas o terminal não acha java”.
Modelo mental: JDK é a caixa de ferramentas para desenvolver. Runtime sozinho não resolve compilação.
Procedimento: instale um JDK LTS, alinhe JAVA_HOME e PATH, valide no terminal.
java -version
javac -versionjavac não aparece, você não tem JDK no PATH. Não discute, prova no terminal.Diagnóstico: IDE abre, mas compila com versão fantasma por SDK não configurado.
Procedimento: instale IntelliJ Community, configure Project SDK apontando para o JDK correto e valide no Project Structure.
Validação: criar classe com main e rodar sem erro de SDK.
HelloWorld com public static void main(String[] args) e o projeto compila.Crie projeto Java, confirme JDK, nomeie projeto e crie classe com main.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}main, não é executável. Crie o main antes de inventar moda.Hello, World!.Erros clássicos: aspas curvas, ponto e vírgula faltando, erro de digitação em println.
System.out.println("Hello, World!");; são os bugs de digitação campeões.Build valida o projeto inteiro, não só a classe clicada.
Use menu Build > Build Project e confirme ausência de erro/compilation failed.
Hello, World! no console.Rode HelloWorld.main() com a classe correta e valide saída no console.
Altere a string, salve e execute novamente para validar o ciclo editar-executar.
System.out.println("Olá! Hoje é dia de rodar Java sem sofrer.");Treine tipagem básica e concatenação sem perder legibilidade.
public class HelloWorld {
public static void main(String[] args) {
int idade = 25;
double altura = 1.78;
String nome = "Ana";
System.out.println("Nome: " + nome);
System.out.println("Idade: " + idade);
System.out.println("Altura: " + altura);
}
}+ funciona, mas preserve legibilidade quando a saída crescer.Evite o bug clássico do newline perdido lendo com nextLine() e fazendo parse explícito.
import java.util.Scanner;
public class HelloWorld {
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());
System.out.println("Nome: " + nome + ", Idade: " + idade);
sc.close();
}
}nextInt() e nextLine() dá ruim; ler tudo como linha evita dor.Introduza um erro de compilação, um erro lógico e um erro de runtime para exercitar diagnóstico real.
Use breakpoint + Debug mode + Step Over/Into + inspeção de variáveis para validar a correção.