O método main em Java é o ponto inicial de execução de qualquer programa. Quando uma aplicação Java é iniciada, a JVM (Máquina Virtual Java) procura especificamente esse método para começar a execução. Sua estrutura é padronizada e essencial para o funcionamento correto do programa.

Estrutura obrigatória do método main

A assinatura correta do método deve seguir exatamente este formato:

public static void main(String[] args) {
    // Código inicial da aplicação
}

• public: O modificador de acesso público permite que a JVM acesse o método de qualquer contexto externo.
• static: Permite que o método seja chamado sem a necessidade de instanciar a classe. A JVM invoca diretamente via nome da classe.
• void: Indica que o método não retorna nenhum valor.
• main: Nome exato e obrigatório. Qualquer variação como Main ou MAIN será ignorada pela JVM.
• String[] args: Array de strings que armazena argumentos passados pela linha de comando.

Uso de argumentos de linha de comando

O parâmetro args é um vetor de String que recebe os valores fornecidos durante a execução no terminal. Cada valor separado por espaço vira um elemento do array.

Exemplo prático:

public class AppExecucao {
    public static void main(String[] args) {
        System.out.println("Total de argumentos: " + args.length);
        for (int indice = 0; indice < args.length; indice++) {
            System.out.println("Arg[" + indice + "] = " + args[indice]);
        }
    }
}

Execução via terminal:

java AppExecucao teste java 2025

Saída esperada:

Total de argumentos: 3
Arg[0] = teste
Arg[1] = java
Arg[2] = 2025

Caso nenhum argumento seja informado, args será um array de comprimento zero, mas nunca null.

Comportamento estático e escopo de acesso

Por ser static, o método main tem acesso direto apenas a membros estáticos da classe. Para acessar atributos ou métodos de instância, é necessário criar um objeto.

public class InicioEstatico {
    private static String mensagemGlobal = "Acesso direto";
    private String mensagemInstancia = "Requer objeto";

    public static void main(String[] args) {
        System.out.println(mensagemGlobal); // Válido

        // System.out.println(mensagemInstancia); // Erro de compilação
        InicioEstatic instancia = new InicioEstatic();
        System.out.println(instancia.mensagemInstancia); // Correto
    }
}

Múltiplos métodos main e sobrecarga

É possível declarar mais de um método chamado main na mesma classe, desde que com diferentes assinaturas (sobrecarga). No entanto, apenas aquele com a assinatura public static void main(String[]) será reconhecido pela JVM como ponto de entrada.

public class MultiMain {
    public static void main(String[] args) {
        System.out.println("Entrada principal");
        main("chamada interna"); // Invocação de overload
    }

    public static void main(String arg) {
        System.out.println("Main alternativo: " + arg);
    }
}

Herdabilidade do método main

Como qualquer método estático, main pode ser herdado. Se uma subclasse não definir seu próprio main, ela poderá usar o da superclasse.

class BaseApp {
    public static void main(String[] args) {
        System.out.println("Executando da classe base");
    }
}

public class AppFilha extends BaseApp {
    // Sem main próprio – herda o da BaseApp
}

Neste caso, executar AppFilha chamará o main de BaseApp. Se a subclasse definir seu próprio main, ele substituirá (esconde) o da superclasse.

Integração com sistema de módulos (Java 9+)

No modelo modular introduzido no Java 9, é necessário declarar explicitamente qual classe contém o método main no arquivo module-info.java:

module aplicacao.modular {
    exports com.exemplo;
    provides java.lang.module.MainClass with com.exemplo.AppExecucao;
}

Boas práticas e cuidados importantes

• O nome main é sensível a maiúsculas/minúsculas — qualquer alteração invalida o ponto de entrada.
• O tipo do parâmetro deve ser String[] ou String... (varargs). Tipos como int[] ou Object[] não são aceitos.
• O método pode declarar exceções: public static void main(String[] args) throws IOException é perfeitamente válido. A JVM trata exceções não capturadas e encerra a aplicação com código de erro.