Como executar Java: compilar com javac e executar com java

Compilar e depois executar

Agora que você tem um JDK instalado, executar Java é um ciclo de dois passos. Diferente de uma linguagem de script, em que você aponta um interpretador para um arquivo e pronto, o Java primeiro compila seu código-fonte legível em bytecode e, em seguida, um passo separado executa esse bytecode na JVM.

Esses dois passos correspondem a duas ferramentas de linha de comando que vêm com o JDK:

• javac - o compilador. Ele lê Main.java e escreve Main.class (bytecode).
• java - o lançador. Ele inicia a JVM e executa o bytecode de Main.class.

Você pode executar qualquer exemplo autossuficiente aqui mesmo na página - o editor abaixo faz os dois passos por você. Mas vale a pena entender o que acontece na sua própria máquina, porque é lá que vivem os projetos reais.

public class Main {
    public static void main(String[] args) {
        System.out.println("Compiled, then run.");
    }
}

Os dois comandos na sua máquina

Digamos que você tem este código salvo como Main.java:

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

Abra um terminal na pasta que contém o arquivo e execute o compilador:

javac Main.java

Se o código compilar sem problemas, o javac não imprime nada e cria um novo arquivo, Main.class, ao lado do seu código-fonte. Esse arquivo .class é o bytecode - não é texto legível e não está atrelado ao seu sistema operacional.

Agora execute-o com o comando java:

java Main

Hello from the terminal

O erro mais comum entre iniciantes está aqui: para iniciar o programa você executa java, não javac, e passa o nome da classe sem extensão. É java Main - nunca java Main.class e nunca java Main.java.

O nome do arquivo deve corresponder à classe pública

O Java impõe uma regra que surpreende os iniciantes: uma classe public deve viver em um arquivo com exatamente o mesmo nome, mais .java. Uma public class Main deve estar em Main.java. Erre nas maiúsculas e o javac se recusa a compilar.

// This is in a file called Greeting.java
public class Greeting {   // ERROR: class Greeting should be in Greeting.java... wait, it is
    public static void main(String[] args) {
        System.out.println("Hi");
    }
}

O descompasso que realmente atrapalha as pessoas é mais sutil - nomear o arquivo como greeting.java (minúsculo) enquanto a classe é Greeting, ou salvar Main.java mas escrever public class Hello. O compilador relata algo como:

Main.java:1: error: class Hello is public, should be declared in a file named Hello.java

A correção é sempre a mesma: faça com que o nome do arquivo e o nome da classe pública sejam idênticos, caractere por caractere.

O atalho: executar um único arquivo diretamente

Desde o JDK 11, você pode pular o passo explícito de compilação para um único arquivo-fonte. O comando java o compilará na memória e o executará de uma só vez - nenhum arquivo .class é gravado no disco:

java Main.java

Isso é perfeito para experimentos rápidos e scripts pequenos. Note a diferença no que você passa:

• java Main - executa um Main.class já compilado.
• java Main.java - compila e executa o arquivo-fonte de uma só vez.

O modo de arquivo único só funciona quando todo o seu programa cabe em um arquivo. No momento em que você divide o código em várias classes em vários arquivos, você volta a compilar primeiro com o javac. Para aprender o básico, o modo de arquivo único mantém o ciclo curto.

Passando argumentos para o seu programa

Lembra do String[] args no main? Esses são os argumentos de linha de comando. Tudo o que você digitar depois do nome da classe no comando java cai naquele array:

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments given.");
        } else {
            System.out.println("First argument: " + args[0]);
            System.out.println("Total arguments: " + args.length);
        }
    }
}

Na sua própria máquina, você passaria argumentos assim:

java Main hello world

First argument: hello
Total arguments: 2

O editor acima não consegue receber argumentos de terminal, então ele executa o ramo "sem argumentos" - mas o mesmo código trata os dois casos. É assim que os programas Java leem a entrada passada no momento da inicialização, muito antes de você chegar a arquivos ou à entrada do usuário.

Lendo as mensagens de erro do compilador

Quando o javac rejeita seu código, ele informa o arquivo, a linha e o que deu errado. Aprender a ler essas mensagens é metade do caminho para se desenrolar. Aqui está um clássico - um ponto e vírgula faltando:

public class Main {
    public static void main(String[] args) {
        System.out.println("Oops")   // no semicolon
    }
}

Main.java:3: error: ';' expected
        System.out.println("Oops")
                                  ^
1 error

O acento circunflexo (^) aponta para onde o compilador esperava algo. Main.java:3 é o arquivo e o número da linha. Resista à vontade de adivinhar - leia a linha, corrija a única coisa que ela aponta e recompile. Erros de compilação significam que nada foi executado ainda; erros de tempo de execução (que têm outra aparência) significam que seu programa iniciou e depois falhou.

Um programa de verificação

Execute isto no editor ou salve-o como Main.java e faça javac Main.java e depois java Main na sua própria máquina. Se você vir as três linhas, sua cadeia de ferramentas funciona de ponta a ponta:

public class Main {
    public static void main(String[] args) {
        System.out.println("1. Java is running");

        int sum = 2 + 2;
        System.out.println("2. Two plus two is " + sum);

        String[] languages = {"Java", "Python", "JavaScript"};
        System.out.println("3. There are " + languages.length + " languages listed");
    }
}

Aparecem aqui três coisas que você conhecerá direito em breve: uma variável int, a concatenação de strings com + e um array com seu .length. Por enquanto, basta que o programa compile e imprima.

Próximo: Sintaxe do Java

Você executou alguns programas, mas estávamos passando por cima da pontuação - as chaves, os pontos e vírgulas, public static void main e por que cada linha tem a aparência que tem. A próxima página desmonta a sintaxe do Java peça por peça, para que a estrutura deixe de parecer código repetitivo e comece a fazer sentido.