O que é e como funciona o método Java main():

O método Java main() é o ponto inicial e final de qualquer programa em Java, já que apenas as instruções dentro do escopo dele são consideradas durante a execução de um código. Por esse motivo, é fundamental que a sintaxe desse método seja seguida à risca durante processos de desenvolvimento. Se ela não estiver correta, o programa não será sequer executado.

O que é método Java main()?

Não importa que projeto que você deseja implementar com essa linguagem de programação, nem se o código em questão é curto ou extenso. No início de todos eles, o método Java main() deve estar presente. Se não estiver, o código não será executado. Antes de ser passada para o main(), a Java Virtual Machine (JVM) é carregada na memória e o código é compilado. Somente depois desses passos o código é passado para o método Java main(), para que seja controlado e, se tudo estiver correto, executado como esperado. Teoricamente, é possível usar esse método incontáveis vezes, mas o máximo recomendável é um método main() por classe.

Sintaxe do método Java main()

A sintaxe do método Java main() segue sempre o mesmo padrão, que consiste em vários componentes importantes. A essa sintaxe dá-se o nome de assinatura.

public static void main(String[] args)

Cada componente desempenha a seguinte função:

• public: Garante que a classe seja acessada também pelo lado de fora.
• static: Declara o método como estático, permitindo que ele exista sem a necessidade da criação de um objeto de classe específico.
• void: Faz com que o método Java main() não precise retornar um valor.
• main: Nome pelo qual a Java Virtual Machine identifica o método ao executar um programa.
• String[] args: Array que armazena e recebe os argumentos da linha de comando.

Função de cada componente do método Java main()

Para que você entenda melhor como funciona o método main() em Java e a importância de cada um de seus componentes, vamos analisa-lo separadamente nos próximos parágrafos. Mais especificamente, mostraremos o que pode acontecer quando faltar uma parte da assinatura. Para isso, elaboramos um exemplo de código muito simples, que vamos imprimir por meio do comando Java System.out.println. Assim ficou o nosso código:

public class main {
public static void main(String[] args) {
System.out.println("Here is your sample text.");
}
}

Quando você executar esse código, o seguinte resultado lhe será exibido:

Here is your sample text.

public

O componente public atua como um especificador de acesso, informando à Java Virtual Machine onde o programa correspondente está sendo executado. Outros modificadores de acesso também existem, como padrão (default), privado (private) e protegido (protected). No entanto, se você tentar usar esses modificadores dentro do método Java main(), receberá uma mensagem de erro:

public class main {
	private static void main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}

O resultado obtido por essa execução seria:

Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

Essa mensagem de erro indica que o método não pode ser acessado publicamente.

static

A natureza estática do método é confirmada pelo uso da palavra-chave static. Ela permite que o main() seja utilizado independentemente das instâncias de classe criadas. Se removermos a declaração static, o código fica assim:

public class main {
	public void main(String[] args) {
		System.out.println("Here is your sample text."");
	}
}

Nesse caso também, uma mensagem de erro é emitida, em vez da saída desejada:

Error: Main method is not static in class test, please define the main method as:
public static void main(String[] args)

void

void é a palavra-chave que indica que o método Java main() não deve retornar valores. Como main() é o ponto de partida e de término de um programa em Java, um retorno é desnecessário. O nosso código sem o componente void ficaria assim:

public class main {
	public static main(String[] args) {
		System.out.println("Here is your sample text.");
	}
}

Essa seria a mensagem de erro gerada pela omissão da palavra-chave:

Error: Main method must return a value of type void in class Main, please define the main method as:
public static void main(String[] args)

main

Em todo programa desenvolvido em Java, a JVM primeiramente procura pelo identificador main. Ele é o responsável por indicar onde a execução deve começar e terminar. Uma vez que o método Java main() for concluído, a saída será encerrada. Portanto, essa assinatura nunca deve ser modificada ou complementada. Ao fazermos isso no nosso exemplo, o nosso código fica assim:

public class main {
	public static void ersatzMain(String[] args) {
		System.out.println("Here is your sample text.");
	}
}

Como, nesse caso, a Java Virtual Machine não consegue encontrar o identificador, ela encerra o programa imediatamente e exibe apenas a seguinte mensagem de erro:

Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

String[] args

O array String[] args corresponde à classe java.lang.String e armazena dados como valores de string. Assim, se omitirmos essa especificação, o código será alterado da seguinte maneira:

public class main {
	public static void main() {
		System.out.println("Here is your sample text."");
	}
}

Sem esse argumento, o método Java main() não pode ser executado. Nessa situação, você receberia novamente a seguinte mensagem de erro:

Error: Main method not found in class, please define the main method as:
public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

Formas alternativas do método Java main()

O exemplo de código que apresentamos nos exemplos acima foram escritos com a sintaxe mais comum. No entanto, ele pode ser ajustado à sua necessidade, para a obtenção de um melhor panorama. Por exemplo, você pode utilizar colchetes diretamente após arg. Ao fazermos isso, o nosso código fica assim:

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

Além disso, você também pode fornecer argumentos como varargs, ou seja, listas de argumentos variáveis:

public static void main(String…args) { }