# 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](https://www.ionos.com/digitalguide/websites/web-development/web-programming-languages/ "Linguagens de programação web"), 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.

```java
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](https://www.ionos.com/digitalguide/websites/web-development/java-commands/ "Comandos Java") `System.out.println`. Assim ficou o nosso código:

```java
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:

```java
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

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

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

```java
public static void main(String…args) { }
```

Dica No nosso Digital Guide, você pode encontrar muitos outros artigos sobre Java. Por exemplo, a nossa comparação entre [Java e JavaScript](https://www.ionos.com/digitalguide/websites/web-development/java-vs-javascript/ "Java vs. Javascript"), que diferencia e explica os dois termos. Conheça, ainda, os principais [operadores de Java](https://www.ionos.com/digitalguide/websites/web-development/java-operators/ "Operadores de Java").


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/metodo-java-main/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/metodo-java-main/) for AI/LLM consumption.