Aprendendo Java do Zero — Parte 1: Pré-requisitos e seu primeiro programa

#Java

Este é o primeiro artigo de uma série voltada a quem quer aprender Java começando exatamente do zero. Depois de pesquisar bastante o que já existe disponível gratuitamente sobre o tema — inclusive os roadmaps mais populares —, resolvi montar minha própria trilha: uma sequência didática unificada, com progressão pensada do primeiro ao último artigo, em vez de uma coleção de links soltos sem fio condutor. A ideia é que cada artigo se apoie no anterior e prepare o próximo, e que quem seguir a série do início ao fim saia com uma base sólida, não só com uma lista de comandos decorados.

Neste artigo, iremos:

entender o que precisa saber antes de começar;
escrever e executar seu primeiro programa em Java, usando um compilador online gratuito;
entender, linha por linha, o que o programa está realmente fazendo, apresentando os conceitos básicos iniciais da linguagem;
conhecer as duas peças que sustentam a portabilidade do Java: a JVM e a dupla JRE/JDK.

Pré-requisitos

A barreira de entrada aqui é baixa. Não é necessário nenhum conhecimento prévio de Java. O único pré-requisito recomendado é ter tido contato com alguma outra linguagem de programação antes — pode ser Python, JavaScript, C, ou qualquer outra.

Isso importa por um motivo simples: ao longo da série, os conceitos específicos de Java (como a sintaxe de classes, tipos de dados, ou a forma como o Java organiza um programa) serão explicados em detalhe. Mas conceitos gerais de programação — o que é uma variável, o que é uma condição, o que é um laço de repetição — serão tratados como algo que você já tem alguma familiaridade, ainda que superficial. Se você nunca programou em lugar nenhum, vale a pena primeiro passar por um curso introdutório de lógica de programação antes de seguir esta trilha, para aproveitar melhor o conteúdo.

Fora isso, não é preciso instalar nada agora. Vamos usar um compilador online.

Como escrever "Hello World" em Java

Antes de instalar qualquer programa no seu computador, é importante garantir que você consiga escrever e rodar um programa simples de Java sem nenhuma dificuldade. Instalação de JDK, configuração de variáveis de ambiente e escolha de IDE ficam para o próximo artigo desta série. Por enquanto, o objetivo será só ver o código funcionando.

Para isso, vamos usar o compilador online do Programiz, disponível em:

https://www.programiz.com/java-programming/online-compiler

Nota: existem várias opções de compilador online disponíveis (Repl.it é uma das mais conhecidas), mas boa parte delas hoje exige criar conta e navegar por um fluxo de configuração mais longo antes de você conseguir rodar a primeira linha de código. Escolhi o Programiz para este primeiro passo justamente porque não exige cadastro e já abre pronto para uso — o que importa aqui é reduzir ao máximo a fricção entre você e o seu primeiro "Hello World".

Passo 1 - Abra o compilador

Acesse o link acima em qualquer navegador. Você vai ver uma tela dividida: de um lado, um editor de código já com um programa de exemplo escrito; do outro (ou logo abaixo, dependendo do tamanho da tela), a área onde o resultado da execução vai aparecer.

Diferente do Repl.it, aqui não existe uma etapa de "criar um novo projeto" ou "escolher um template" — o ambiente já vem carregado com um exemplo funcional de Java, pronto para ser executado ou editado.

Passo 2 - Substitua o código de exemplo

Apague o conteúdo que já está no editor e escreva o seguinte:

class Main {
  public static void main(String[] args) {
     System.out.println("Hello world!");
  }
}

Passo 3 - Execute

Procure o botão de Run (executar) — normalmente fica destacado em verde, acima ou ao lado do editor. Clique nele.

Se estiver tudo certo, a área de saída (às vezes chamada de console ou output) vai mostrar:

Hello world!

Parabéns — esse é o seu primeiro programa Java rodando de ponta a ponta, sem precisar instalar nada.

O que está acontecendo no código?

Esse programa de "Hello World" é, provavelmente, o programa executável mais simples que se pode escrever em Java — e ainda assim, entender exatamente o que cada linha faz é importante, porque essa estrutura vai se repetir em praticamente todo programa Java que você escrever daqui para frente.

Vamos abrir o código em partes.

A linha da classe

class Main {
// ...
}

Essa linha cria uma classe chamada `Main`. Uma classe, de forma simples, é um jeito de agrupar um bloco de código relacionado dentro de uma única unidade — pense nela como um "container" com nome.

Em Java, todo código precisa estar dentro de uma classe. Não existe a possibilidade de simplesmente soltar instruções soltas em um arquivo, como acontece em Python, por exemplo — tudo mora dentro de uma classe.

Quando você compila localmente (fora de um compilador online), essa classe costuma ser declarada como `public`, o que significa que ela pode ser acessada de qualquer lugar do projeto. E há uma regra importante ligada a isso: um arquivo-fonte Java (arquivos com extensão `.java`) só pode conter uma classe `public` de nível superior, e o nome dessa classe precisa ser exatamente igual ao nome do arquivo. Ou seja: uma classe `public class HelloWorld` só pode viver dentro de um arquivo chamado `HelloWorld.java`.

Como no Programiz você não está lidando diretamente com arquivos e nomes de arquivo (o compilador cuida disso nos bastidores), essa regra fica invisível por enquanto — mas é essencial guardá-la, porque ela vai aparecer com força total assim que você instalar Java localmente ou usar uma IDE, no próximo artigo desta série.

A linha do método principal

class Main {
  public static void main(String[] args) {
      System.out.println("Hello world!");
  }
}

Dentro da classe, temos essa linha:

public static void main(String[] args) {
// ...
}

Essa é a função `main` — e ela é especial em Java. Se você já teve contato com linguagens como C, C++ ou Go, esse conceito vai soar familiar: todo programa nessas linguagens tem uma função `main`, e é exatamente por ali que a execução do programa começa. Em Java funciona do mesmo jeito.

A assinatura dessa função precisa ser escrita exatamente como está acima: `public static void main(String[] args)`. Qualquer alteração — trocar o tipo de retorno, mudar a ordem das palavras, esquecer os colchetes — faz o compilador reclamar. Não é intolerância da linguagem: é a JVM (que vamos conhecer daqui a pouco) procurando especificamente por essa assinatura para saber onde começar a rodar o seu programa. Se ela não encontrar exatamente esse formato, simplesmente não sabe por onde começar.

Rapidamente, o que cada palavra dessa assinatura significa:

`public` - o método pode ser acessado de qualquer lugar.
`static` - significa que você pode chamar esse método sem precisar antes criar um objeto da classe. Isso vai fazer mais sentido quando falarmos de classes e objetos, mais adiante na série.
`void` - indica que esse método não devolve nenhum valor como resultado.
`String[] args` — indica que o método recebe, como entrada, uma lista (um *array*) de textos. Essa lista guarda argumentos passados por linha de comando na hora de executar o programa — algo que você provavelmente não vai usar nos primeiros artigos desta série, mas que está sempre ali, presente na assinatura.

A linha que realmente imprime algo

System.out.println("Hello world!");

Essa é a linha que efetivamente escreve algo na tela. `System.out.println` é o comando responsável por imprimir um texto no console, seguido de uma quebra de linha. No exemplo, o texto `"Hello world!"` é passado para esse comando, e é exatamente por isso que `Hello world!` aparece na saída.

Repare também no ponto e vírgula no final da linha. Em Java, toda instrução termina com ponto e vírgula — diferente de linguagens como Python ou, em muitos casos, JavaScript, onde ele é opcional. Esquecer o ponto e vírgula em Java não gera um aviso: gera um erro de compilação, e o programa simplesmente não roda até isso ser corrigido.

Por enquanto, fica o essencial para levar adiante: em todo arquivo Java, a classe pública de nível superior precisa ter o mesmo nome do arquivo, e o ponto de entrada de qualquer programa Java é sempre um método escrito exatamente como `public static void main(String[] args)`.

O que é a JVM?

Uma das grandes promessas do Java é ser "cross-platform" — ou seja, um código escrito e compilado em uma plataforma consegue rodar em qualquer outra plataforma que tenha Java instalado, sem precisar recompilar.

Para entender como isso é possível, é preciso lembrar de uma coisa: o processador do seu computador não entende texto, nem lógica de alto nível. A única coisa que ele realmente entende são sequências de zeros e uns — binário.

Quando você escreve e compila um programa em C++, por exemplo, o resultado é um arquivo binário específico para aquela plataforma. Um processador com arquitetura AMD64 e um com arquitetura ARMv8-A têm conjuntos de instruções diferentes — então, para rodar o mesmo programa nos dois, você precisaria compilá-lo separadamente para cada um.

O Java resolve isso de um jeito diferente. Quando você compila um programa Java, o resultado não é um binário direto para o processador — é um formato intermediário chamado bytecode. Esse bytecode não é binário puro, mas também não é um texto legível por humanos, e o processador sozinho não sabe interpretá-lo.

É aí que entra a JVM — Java Virtual Machine (Máquina Virtual Java). Em vez de entregar o bytecode diretamente ao processador, o Java executa esse bytecode através da JVM, que interpreta as instruções e as traduz para o que o processador daquela plataforma específica consiga entender.

Isso é o que sustenta a filosofia "escreva uma vez, rode em qualquer lugar": o mesmo bytecode compilado roda em Windows, Linux ou macOS, desde que cada um tenha sua própria JVM instalada. A JVM é a peça que absorve as diferenças entre as plataformas, para que o seu código-fonte não precise se preocupar com elas.

O que são JRE e JDK?

Duas siglas aparecem o tempo todo quando se fala em configurar Java: JRE (Java Runtime Environment) e JDK (Java Development Kit).

O JRE empacota uma implementação da JVM junto com o conjunto de bibliotecas necessário para *executar* programas Java já prontos.
O JDK vai além: ele empacota o JRE inteiro, mais todas as ferramentas necessárias para *desenvolver* programas Java (compilador, depurador, e outras ferramentas de linha de comando).

Ou seja: se você só quer rodar programas Java no seu computador, o JRE já basta. Se você quer escrever e compilar seus próprios programas — que é justamente o que faremos a partir do próximo artigo — você precisa do JDK.

Existem várias implementações do JDK disponíveis. A Oracle distribui o Java SE (Standard Edition) Development Kit, e existe também o OpenJDK, a implementação de referência open-source do Java SE. Por ser open-source, o OpenJDK tem diversos "builds" (compilações) distribuídos por empresas diferentes, como o Adoptium e o Microsoft Build of OpenJDK — todos compatíveis entre si na prática.

Resumindo a relação entre os três: a JVM é a peça central de execução; o JRE é a JVM mais as bibliotecas de execução; e o JDK é o JRE mais as ferramentas de desenvolvimento. Cada um é um superconjunto do anterior.

O que vem a seguir

Neste primeiro artigo, nós demos os passos iniciais em Java sem precisar instalar absolutamente nada: escrevemos e rodamos nosso primeiro programa em um compilador online, entendemos por dentro o que cada linha do "Hello World" realmente significa, e conhecemos os bastidores que tornam o Java uma linguagem portável — a JVM, o JRE e o JDK.

Na Parte 2 desta série, vamos sair do compilador online e montar um ambiente de desenvolvimento completo, local, no seu computador. O próximo artigo começar[a exatamente em "Como instalar o Java no seu computador", e vai cobrir:

o download e a instalação do JDK a partir do site oficial da Oracle;
a instalação de uma IDE Java (IntelliJ IDEA, na edição Community, gratuita);
a criação do seu primeiro projeto Java "de verdade" dentro da IDE, recriando o mesmo "Hello World" — só que agora rodando localmente, fora do navegador.

Bons estudos e até lá!

Este artigo é parte de uma série de introdução a Java escrita do zero por mim, com progressão didática própria pensada para quem nunca programou na linguagem antes.