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 ins­tru­ções dentro do escopo dele são con­si­de­ra­das durante a execução de um código. Por esse motivo, é fun­da­men­tal que a sintaxe desse método seja seguida à risca durante processos de de­sen­vol­vi­mento. 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 im­ple­men­tar com essa linguagem de pro­gra­ma­çã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 con­tro­lado e, se tudo estiver correto, executado como esperado. Te­o­ri­ca­mente, é possível usar esse método in­con­tá­veis vezes, mas o máximo re­co­men­dá­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 com­po­nen­tes im­por­tan­tes. A essa sintaxe dá-se o nome de as­si­na­tura.

public static void main(String[] args)

Cada com­po­nente de­sem­pe­nha 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, per­mi­tindo que ele exista sem a ne­ces­si­dade da criação de um objeto de classe es­pe­cí­fico.
• void: Faz com que o método Java main() não precise retornar um valor.
• main: Nome pelo qual a Java Virtual Machine iden­ti­fica o método ao executar um programa.
• String[] args: Array que armazena e recebe os ar­gu­men­tos da linha de comando.

Função de cada com­po­nente do método Java main()

Para que você entenda melhor como funciona o método main() em Java e a im­por­tân­cia de cada um de seus com­po­nen­tes, vamos analisa-lo se­pa­ra­da­mente nos próximos pa­rá­gra­fos. Mais es­pe­ci­fi­ca­mente, mos­tra­re­mos o que pode acontecer quando faltar uma parte da as­si­na­tura. Para isso, ela­bo­ra­mos 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 com­po­nente public atua como um es­pe­ci­fi­ca­dor de acesso, in­for­mando à Java Virtual Machine onde o programa cor­res­pon­dente está sendo executado. Outros mo­di­fi­ca­do­res de acesso também existem, como padrão (default), privado (private) e protegido (protected). No entanto, se você tentar usar esses mo­di­fi­ca­do­res 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 pu­bli­ca­mente.

static

A natureza estática do método é con­fir­mada pelo uso da palavra-chave static. Ela permite que o main() seja utilizado in­de­pen­den­te­mente das ins­tân­cias de classe criadas. Se re­mo­ver­mos a de­cla­ra­çã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 é des­ne­ces­sá­rio. O nosso código sem o com­po­nente 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 de­sen­vol­vido em Java, a JVM pri­mei­ra­mente procura pelo iden­ti­fi­ca­dor main. Ele é o res­pon­sá­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 as­si­na­tura nunca deve ser mo­di­fi­cada ou com­ple­men­tada. 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 iden­ti­fi­ca­dor, ela encerra o programa ime­di­a­ta­mente 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 cor­res­ponde à classe java.lang.String e armazena dados como valores de string. Assim, se omitirmos essa es­pe­ci­fi­ca­çã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 al­ter­na­ti­vas do método Java main()

O exemplo de código que apre­sen­ta­mos nos exemplos acima foram escritos com a sintaxe mais comum. No entanto, ele pode ser ajustado à sua ne­ces­si­dade, para a obtenção de um melhor panorama. Por exemplo, você pode utilizar colchetes di­re­ta­mente 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 ar­gu­men­tos como varargs, ou seja, listas de ar­gu­men­tos variáveis:

public static void main(String…args) { }