Java javac e java

Um programa Java chega à tela em duas etapas: o javac compila o arquivo .java e gera um .class; o java executa esse .class. Nesta aula você faz o caminho completo no terminal, conhece o atalho java Main.java e aprende a reconhecer os erros mais comuns de quem compila e roda pela primeira vez.

Você precisa do JDK instalado (Linux, Windows e macOS). As sessões são do terminal da Ana, com o JDK 25; no Windows, os comandos javac e java são os mesmos. Se ainda não tem o JDK, acompanhe pelas caixas Experimente.

A ideia: traduzir uma vez, ler muitas

Pense num livro escrito em português que vai ser lido por uma máquina que só entende uma língua especial. Você contrata um tradutor (o javac), que traduz o livro inteiro de uma vez e entrega a versão traduzida (o .class). Depois, um leitor (o java, que liga a JVM) lê a versão traduzida quantas vezes quiser, sem precisar do tradutor.

  Main.java  ──── javac Main.java ────►  Main.class  ──── java Main ────►  Olá, mundo!
 (código-fonte,     (compila: confere      (bytecode)      (executa: a JVM     (a saída)
  você escreve)      e traduz)                              lê o bytecode)

Se o livro original mudar, a tradução antiga continua igual até alguém traduzir de novo. Guarde essa ideia: ela explica uma das surpresas desta aula.

Passo 1: o arquivo

A Ana cria uma pasta para o programa e escreve o arquivo Main.java com o editor dela (veja Editores e IDEs). Para conferir o conteúdo pelo terminal, o cat mostra o arquivo:

$ mkdir -p ~/java/ola
$ cd ~/java/ola
$ cat Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, mundo!");
    }
}

O programa é o da aula Olá, Mundo. Lembre: a classe se chama Main, então o arquivo se chama Main.java.

Passo 2: compilar com javac

javac

O compilador do Java (Java compiler). Lê o código, confere se segue as regras da linguagem e gera o bytecode.

Main.java

O arquivo a compilar, com a extensão .java. Maiúsculas e minúsculas contam.

$ javac Main.java
$ echo $?
0                                 « código de saída 0: compilou sem erro

O javac não escreveu nada. No terminal, silêncio quer dizer sucesso: se houvesse um erro, ele mostraria a mensagem. O echo $? mostra o código de saída do último comando; 0 confirma que deu certo. O que mudou foi a pasta:

$ ls -l
total 8
-rw-rw-r-- 1 ana ana 414 out 16 18:44 Main.class     « novo: o bytecode, 414 bytes
-rw-rw-r-- 1 ana ana 117 out 16 18:44 Main.java      « o seu código, 117 bytes

Apareceu o Main.class, com o nome da classe (não do arquivo) e a extensão .class. É ele que a JVM vai executar. Se tiver curiosidade sobre o que tem dentro, a aula JDK, JRE e JVM abre um .class com o javap.

Passo 3: executar com java

java

O lançador: liga a JVM e pede a ela para executar uma classe.

Main

O nome da classe, sem .class e sem .java. A JVM procura o arquivo Main.class sozinha, na pasta atual, e começa pelo método main.

$ java Main
Olá, mundo!
$ echo $?
0                                 « o programa terminou normalmente

Pronto: compilou uma vez, rodou. Você pode rodar java Main de novo quantas vezes quiser, sem compilar outra vez.

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("Compilei");
        System.out.println("e rodei!");
    }
}

A surpresa: mudei o código e nada mudou

A Ana troca mundo por Ana no arquivo (aqui, com o comando sed, que edita texto pelo terminal; no dia a dia, ela usaria o editor) e roda de novo:

$ sed -i 's/Olá, mundo!/Olá, Ana!/' Main.java
$ cat Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("Olá, Ana!");            « o código-fonte mudou
    }
}
$ java Main
Olá, mundo!                                         « mas a saída é a antiga!

O java executa o Main.class, e o Main.class ainda é a "tradução" antiga. O .java mudou; o .class, não. É preciso compilar de novo:

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

O atalho: java Main.java Java 11+

Desde o Java 11, o java aceita direto um arquivo .java. Ele compila o código na memória e já executa, sem criar .class nenhum. É o modo arquivo-fonte (source-file mode):

$ rm Main.class                « apaga o .class, para mostrar que não precisa dele
$ java Main.java
Olá, Ana!
$ ls
Main.java                      « nenhum .class foi criado

Como não sobra .class, o java Main (sem .java) agora não tem o que executar:

$ java Main
Erro: Não foi possível localizar nem carregar a classe principal Main
Causada por: java.lang.ClassNotFoundException: Main

Se o código tiver erro, o modo arquivo-fonte mostra a mensagem do compilador, mais uma linha error: compilation failed ("a compilação falhou"):

$ java Erro.java
Erro.java:2: error: ';' expected
    IO.println("Oi")
                    ^
1 error
error: compilation failed

Qual usar?

Nas aulas, você vai ver os dois. Quando a saída é o que importa, o guia usa java Main.java; quando o processo importa, usa javac e java separados. Desde o Java 22, o modo arquivo-fonte também encontra as outras classes do programa em arquivos .java da mesma pasta.

Outra forma: separar o código do bytecode

Em projetos maiores, misturar .java e .class na mesma pasta vira bagunça. A opção -d (de directory, pasta) do javac manda os .class para outro lugar, e a opção -cp (de classpath, "caminho das classes") do java diz onde procurá-los:

$ javac -d classes Main.java          « os .class vão para a pasta classes (criada sozinha)
$ ls -R
.:
classes  Main.java

./classes:
Main.class
$ java -cp classes Main               « procure as classes na pasta classes
Olá, Ana!

O classpath é a lista de lugares onde a JVM procura classes. Quando você não diz nada, ele é a pasta atual (.). Por isso o java Main só funciona na pasta onde está o Main.class. Ferramentas como o Maven e o Gradle fazem essa organização por você.

Quando dá errado

Os erros desta seção são os do caminho entre o arquivo e a execução. Os erros no código (ponto e vírgula, nomes) estão em Lendo Erros do javac.

$ java Main.class
Erro: Não foi possível localizar nem carregar a classe principal Main.class
Causada por: java.lang.ClassNotFoundException: Main.class
$ echo $?
1

$ java main
Erro: Não foi possível localizar nem carregar a classe principal main
Causada por: java.lang.ClassNotFoundException: main

$ cd ~
$ java Main
Erro: Não foi possível localizar nem carregar a classe principal Main
Causada por: java.lang.ClassNotFoundException: Main

$ javac main.java
error: file not found: main.java
Usage: javac <options> <source files>
use --help for a list of possible options

$ javac Main
error: Class names, 'Main', are only accepted if annotation processing is explicitly requested
1 error

$ 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

$ javac Main.java
$ /usr/lib/jvm/java-21-openjdk-amd64/bin/java Main
Erro: ocorreu LinkageError ao carregar a classe principal Main
	java.lang.UnsupportedClassVersionError: Main has been compiled by a more recent version of the Java Runtime (class file version 69.0), this version of the Java Runtime only recognizes class file versions up to 65.0
$ echo $?
1

$ javac --release 21 Main.java && /usr/lib/jvm/java-21-openjdk-amd64/bin/java Main
Olá, mundo!

Os códigos de saída

Todo programa devolve um número ao terminar, o código de saída, que o terminal guarda em $? (no Windows: %ERRORLEVEL% no Prompt de Comando, $LASTEXITCODE no PowerShell). Scripts e ferramentas usam esse número para saber se algo deu certo.

Um programa pode escolher o próprio código com System.exit, que encerra o programa na hora:

public class Sai {
    public static void main(String[] args) {
        System.out.println("antes");
        System.exit(3);
    }
}

$ java Sai.java; echo $?
antes
3                                  « o número passado ao System.exit

E um programa que termina com exceção devolve 1:

$ java Div.java; echo $?
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Div.main(Div.java:3)
1

public class Main {
    public static void main(String[] args) {
        System.out.println("Verificando o estoque...");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Verificando o estoque...");
        System.out.println("Estoque vazio");
        System.exit(3);
    }
}

Referência

Exercícios

Resumo

• javac Main.java compila (com .java) e gera Main.class; silêncio = sucesso.
• java Main executa a classe (sem extensão); procura o .class na pasta atual ou no -cp.
• Mudou o .java? Compile de novo. Ou use javac Main.java && java Main.
• java Main.java Java 11+ compila na memória e roda, sem .class.
• "Não foi possível localizar nem carregar a classe principal" = nome errado (.class, maiúscula) ou pasta errada.
• UnsupportedClassVersionError = .class de um Java mais novo que o java que roda; use um Java mais novo ou --release.
• Códigos de saída: 0 sucesso; 1 erro de compilação ou exceção; System.exit(N) devolve N.