Java Olá, Mundo

Todo curso de programação começa com um programa que escreve "Olá, mundo!" na tela. Em Java, esse programa tem cinco linhas, e quatro delas são uma "moldura" cheia de palavras estranhas: public, class, static, void. Nesta aula você vai entender cada uma, sem pular nenhuma, e conhecer também a forma curta que o Java 25 permite.

Os programas desta aula foram compilados e executados com o JDK 25 na máquina da Ana, na pasta ~/java. Como compilar e executar, passo a passo, é a próxima aula: javac e java. Aqui, use as caixas Experimente.

O programa

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
    }
}

$ javac Main.java
$ java Main
Olá, mundo!

Uma linha de saída, de uma linha de código "útil". Antes de destrinchar, rode você mesmo:

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, Ana!");
    }
}

A ideia: um prédio, uma porta de entrada

Pense num prédio comercial. O prédio tem um nome na fachada ("Edifício Main"). Lá dentro há várias salas, mas todo visitante entra pela mesma porta, a portaria, e só depois vai para onde precisa.

• A classe é o prédio: tudo o que você escreve em Java fica dentro de uma classe, e ela tem um nome (Main).
• O método main é a portaria: quando você roda o programa, o Java procura um método chamado main e começa por ele. Sem portaria, ninguém entra.
• As instruções dentro do main (como o println) são o que acontece depois que se entra: executadas uma a uma, de cima para baixo.

Agora as cinco linhas, uma de cada vez.

Linha 1: public class Main {

Esta linha declara uma classe: cria o "prédio" e dá um nome a ele.

public

"Público": a classe pode ser usada por qualquer parte do programa. É um modificador de acesso (você vai conhecer os outros em Modificadores de Acesso). Uma classe public tem uma regra extra: o arquivo precisa ter o nome dela (seção O nome do arquivo).

class

"Classe": avisa que vem a declaração de uma classe. É uma palavra reservada do Java: tem significado fixo e não pode ser usada como nome.

Main

O nome da classe, escolhido por você. Main quer dizer "principal" e é uma convenção comum para a classe que inicia o programa. Poderia ser Ola, Loja, MeuPrograma. Por costume, nomes de classe começam com letra maiúscula.

{

Abre o corpo da classe: tudo até a chave } correspondente (a da linha 5) pertence à classe Main.

Linha 2: public static void main(String[] args) {

A linha mais assustadora. Ela declara um método: um bloco de instruções com nome, que pode ser executado (você vai criar os seus em Métodos). Este se chama main e é a porta de entrada do programa. Palavra por palavra:

public

"Público": o método pode ser chamado de fora da classe. Precisa ser, porque quem chama o main é a JVM, de fora.

static

"Estático", no sentido de "pertence à classe". Um método static pode ser chamado sem criar nenhum objeto antes. É por isso que a JVM consegue chamar o main logo de cara. (O que é "criar um objeto" é assunto de Classes e Objetos; os detalhes de static estão em static.)

void

"Vazio": o método não devolve nenhum resultado. Ele faz coisas (escreve na tela), mas não responde com um valor. Métodos que devolvem valores aparecem em Valores de Retorno.

main

"Principal": o nome do método. Este nome não é escolha sua: a JVM procura exatamente main, com letra minúscula.

(String[] args)

Os parâmetros: o que o método recebe. String[] é "uma lista de textos" e args (de arguments, argumentos) é o nome dessa lista. Ela traz o que você escrever depois do nome do programa no terminal; por enquanto, fica vazia. Veja Argumentos da Linha de Comando.

{

Abre o corpo do método: as instruções que rodam quando o programa começa.

Linha 3: System.out.println("Olá, mundo!");

A única linha que faz algo visível: escreve um texto na tela. É uma instrução (em inglês, statement): uma ordem completa.

System

Uma classe que vem pronta com o Java e representa o sistema onde o programa roda.

.out

A saída padrão do sistema (normalmente, o terminal). O ponto quer dizer "o out que pertence a System".

.println

O método que escreve e depois pula para a próxima linha (print line, "imprimir linha").

( … )

Os parênteses levam ao método o que ele deve escrever.

"Olá, mundo!"

Um texto (em Java, uma String). As aspas duplas marcam o começo e o fim; elas não aparecem na tela.

;

Fim da instrução.

O println tem um irmão, o print, que não pula linha; e escreve números e contas também. Tudo isso está em Saída: print e println.

Linhas 4 e 5: } e }

A chave da linha 4 fecha o método main (a que foi aberta na linha 2). A da linha 5 fecha a classe Main (aberta na linha 1). Quando o main chega à sua chave final, o programa termina.

Resumo das cinco linhas

Chaves e ponto e vírgula

Dois símbolos dão forma a todo programa Java.

As chaves { } são caixas

Cada { abre uma caixa e cada } fecha a caixa aberta mais recentemente. O main fica dentro da classe; o println fica dentro do main:

┌ public class Main {                                   ← caixa da classe
│   ┌ public static void main(String[] args) {          ← caixa do método, dentro da classe
│   │     System.out.println("Olá, mundo!");            ← instrução, dentro do método
│   └ }
└ }

Toda chave aberta precisa ser fechada. Os espaços no começo das linhas (o recuo, ou indentação) não são obrigatórios para o Java, mas mostram para quem lê quem está dentro de quem. A convenção é de 4 espaços por nível. Veja Sintaxe e Estrutura.

O ponto e vírgula ; termina uma instrução

O ; é o ponto final das frases do Java. Toda instrução termina com ele. As linhas que abrem uma caixa (public class Main {) e as chaves que fecham não levam ponto e vírgula, porque não são instruções: são a moldura.

Um programa com várias instruções executa uma depois da outra, de cima para baixo:

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
        System.out.println("Meu nome é Ana.");
        System.out.println("Estou aprendendo Java.");
    }
}

$ java Main.java
Olá, mundo!
Meu nome é Ana.
Estou aprendendo Java.

Esquecer o ; é o erro mais comum de quem começa. O javac avisa: error: ';' expected ("esperava um ;"), apontando o fim da linha. Esse e outros erros estão em Lendo Erros do javac.

O nome do arquivo = o nome da classe

A regra: uma classe public chamada Main precisa estar num arquivo chamado exatamente Main.java. Mesmas letras, mesmas maiúsculas. Se a classe se chama Loja, o arquivo é Loja.java.

Veja o que acontece quando a Ana copia o programa para um arquivo chamado Ola.java, sem mudar o nome da classe:

$ javac Ola.java
Ola.java:1: error: class Main is public, should be declared in a file named Main.java
public class Main {
       ^
1 error

A mensagem é direta: "a classe Main é pública e deveria estar declarada num arquivo chamado Main.java". Duas formas de consertar: renomear o arquivo para Main.java, ou mudar a classe para public class Ola.

Por que essa regra? Para o Java achar as classes rapidamente: quando um programa usa a classe Loja, o compilador sabe que deve procurá-la no arquivo Loja.java. E o javac gera o .class com o nome da classe, não do arquivo: a classe Main vira Main.class.

public class Main {
    public static void main(String[] args) {
        System.out.println("Bem-vinda à Loja da Ana");
    }
}

public class Loja {
    public static void main(String[] args) {
        System.out.println("Bem-vinda à Loja da Ana");
    }
}

O que pode e o que não pode mudar no main

A JVM procura o main pelo nome e pela forma. Algumas variações são aceitas; outras fazem a JVM não achar a porta de entrada. Todas estas foram testadas no JDK 25:

Quando a JVM não acha um main válido, o programa compila mas não roda. A mensagem em português tem um erro de tradução do próprio JDK 25 (a frase sai embaralhada, citando o JavaFX, uma biblioteca de janelas que nem está em jogo):

$ javac Main.java                « compila sem erro
$ java Main
Erro: o método main não é Main na classe javafx.application.Application; defina o método main como:
   public static void main(String[] args)

Num sistema em inglês, a mesma mensagem é legível: Error: Main method not found in class Main, please define the main method as: public static void main(String[] args), "método main não encontrado na classe Main; defina o método main como…". Em qualquer língua, o recado é: confira se o método se chama main (minúsculo) e se está escrito como na linha 2.

O main simplificado do Java 25 Java 25+

Para quem está começando, a moldura da classe e o public static void main(String[] args) são muita coisa de uma vez. O Java 25 trouxe uma forma curta, pensada para programas pequenos e para o ensino (o recurso se chama compact source files and instance main methods, "arquivos-fonte compactos e métodos main de instância"):

void main() {
    IO.println("Olá, mundo!");
}

$ java Main.java
Olá, mundo!
$ javac Main.java && ls && java Main
Main.class  Main.java        « o javac criou a classe Main sozinho, a partir do nome do arquivo
Olá, mundo!

void main()

O método de entrada, sem public, sem static e sem parâmetros. Não há class em volta: o arquivo inteiro vira uma classe "implícita", que ganha o nome do arquivo.

IO.println

IO é uma classe nova do Java 25 (de input/output, "entrada e saída") com métodos simples: IO.println (escreve e pula linha), IO.print (escreve sem pular) e IO.readln (lê uma linha do teclado). Faz o mesmo que System.out.println.

Na forma curta, o System.out.println continua funcionando, e o IO.readln lê o teclado sem precisar do Scanner. Um exemplo com as duas formas de escrever e uma pergunta (a entrada Ana veio de fora, por isso não aparece na tela):

void main() {
    IO.println("Oi");
    System.out.println("também funciona");
    String nome = IO.readln("Seu nome: ");
    IO.println("Prazer, " + nome);
}

$ echo Ana | java Ola.java
Oi
também funciona
Seu nome: Prazer, Ana

void main() {
    IO.println("Olá, mundo!");
}

void main() {
    IO.println("Olá do Java 25!");
}

Num Java mais antigo, a forma curta não compila

Compilando a forma curta como se fosse o Java 21:

$ javac --release 21 Main.java
Main.java:1: error: implicitly declared classes are not supported in -source 21
void main() {
^
  (use -source 25 or higher to enable implicitly declared classes)
1 error

"Classes declaradas implicitamente não são suportadas no Java 21; use 25 ou maior." Num computador com Java 17 ou 21 (muito comum em escolas e empresas), a forma curta simplesmente não funciona.

Qual forma usar? E por que o guia usa a clássica

O guia usa a forma clássica por padrão, por três motivos:

1. É o que você vai ler no mundo real. Quase todo o código Java existente, inclusive o das empresas que usam Java 8, 11, 17 e 21, tem a classe e o public static void main(String[] args).
2. Funciona em qualquer Java. Se a sua escola ou empresa tiver um Java 17, os exemplos do guia rodam igual.
3. As classes são o coração do Java. A partir do Nível 2, todo programa tem várias classes, e a forma curta não serve para isso. Escrever public class Main desde o primeiro dia deixa essa moldura familiar.

A forma simplificada aparece quando for útil, sempre com o selo Java 25+. Para um teste rápido de uma linha, há ainda uma terceira opção, sem arquivo nenhum: o JShell.

Quando dá errado

$ javac Main.java
Main.java:4: error: reached end of file while parsing
    }
     ^
1 error

public class Main {
    public static void main(String[] args); {
        System.out.println("Olá, mundo!");
    }
}

$ javac Main.java
Main.java:2: error: missing method body, or declare abstract
    public static void main(String[] args); {
                       ^
1 error

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!")
        system.out.println("Meu nome é Ana.");
        System.out.println(Estou aprendendo Java.);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
        System.out.println("Meu nome é Ana.");
        System.out.println("Estou aprendendo Java.");
    }
}

Exercícios

Resumo

• public class Main { cria a classe; o arquivo precisa se chamar Main.java.
• public static void main(String[] args) { é a porta de entrada: público, da classe (static), não devolve nada (void), recebe os argumentos.
• System.out.println("…"); escreve o texto e pula linha.
• { } são caixas, uma dentro da outra; ; termina cada instrução (não as linhas que abrem chaves).
• As instruções do main rodam de cima para baixo; o programa termina na } do main.
• Java 25+ void main() { IO.println("…"); } é a forma curta. O guia usa a clássica por padrão, porque funciona em qualquer Java e é a que você vai encontrar.