O main() é o ponto de partida para a JVM iniciar a execução de um programa Java. Sem o método main(), a JVM não executará o programa. A sintaxe do método main() é:
público: É um especificador de acesso. Devemos usar uma palavra-chave pública antes do método main() para que a JVM possa identificar o ponto de execução do programa. Se usarmos private, protected e default antes do método main(), ele não será visível para a JVM.
estático: Você pode tornar um método estático usando a palavra-chave static. Devemos chamar o método main() sem criar um objeto. Métodos estáticos são os métodos que invocam sem criar os objetos, portanto não precisamos de nenhum objeto para chamar o método main().
vazio: Em Java, todo método possui o tipo de retorno. A palavra-chave Void reconhece ao compilador que o método main() não retorna nenhum valor.
principal(): É uma assinatura padrão predefinida na JVM. É chamado pela JVM para executar um programa linha por linha e encerrar a execução após a conclusão deste método. Também podemos sobrecarregar o método main().
Argumentos de string[]: O método main() também aceita alguns dados do usuário. Ele aceita um grupo de strings, que é chamado de array de strings. É usado para armazenar os argumentos da linha de comando na forma de valores de string.
main(String args[])
Aqui, agrs[] é o nome do array e é do tipo String. Isso significa que ele pode armazenar um grupo de strings. Lembre-se de que esse array também pode armazenar um grupo de números, mas apenas na forma de string. Os valores passados para o método main() são chamados de argumentos. Esses argumentos são armazenados no array args[], então o nome args[] geralmente é usado para isso.
O que acontece se o método main() for escrito sem String args[]?
O programa irá compilar, mas não será executado, porque a JVM não reconhecerá o método main(). Lembre-se de que a JVM sempre procura o método main() com um array do tipo string como parâmetro.
Processo de Execução
Primeiro, a JVM executa o bloco estático, depois executa métodos estáticos e, em seguida, cria o objeto necessário ao programa. Finalmente, ele executa os métodos de instância. A JVM executa um bloco estático com base na prioridade mais alta. Isso significa que a JVM vai primeiro para o bloco estático antes mesmo de procurar o método main() no programa.
Exemplo
class Demo { static //static block { System.out.println('Static block'); } public static void main(String args[]) //static method { System.out.println('Static method'); } } Saída:
Static block Static method
Observamos que a JVM executa primeiro o bloco estático, se estiver presente no programa. Depois disso, ele procura o método main(). Se o método main() não for encontrado, ocorre um erro.
Exemplo
Um programa que não possui o método main() apresenta um erro em tempo de execução.
class DemoStaticBlock { Static //static block { System.out.println('Static block'); } } Saída:
Error: Main method not found in the class Demo, please define the main method as: public static void main(String[] args) or a JavaFX application class must extend javafx.application.Application
Portanto, o método main() deve sempre ser escrito como:
public static void main(String args[])
Podemos trocar público e estático e escrevê-lo da seguinte forma:
static public void main(String args[])
Também podemos usar o nome diferente para o array do tipo String e escrevê-lo como:
static public void main(String[] x)
Diferentes maneiras de escrever o método main() são:
static public void main(String []x) static public void main(String...args)
String...argumentos: Ele permite que o método aceite zero ou vários argumentos. Deve haver exatamente três pontos entre String e array; caso contrário, ocorrerá um erro.
Exemplo
Um programa que não possui o método main(), mas é compilado e executado com sucesso.
abstract class DemoNoMain extends javafx.application.Application { static //static block { System.out.println('Java'); System.exit(0); } } Saída:
Java
Sobrecarga do método main()
Também podemos sobrecarregar o método main(). Podemos definir qualquer número de métodos main() na classe, mas a assinatura do método deve ser diferente.
Exemplo
class OverloadMain { public static void main(int a) //overloaded main method { System.out.println(a); } public static void main(String args[]) { System.out.println('main method incoked'); main(6); } } Saída:
encadeamento direto
main method invoked 6