# Método principal Java: o ponto de início e fim de todos os programas Java

O método Java `main()` ou método main em Java é o ponto de início e fim de todo programa em Java. Durante a execução, apenas as instruções que estão dentro do seu âmbito são consideradas. É por isso que é tão importante que a sintaxe do método seja respeitada até ao mais ínfimo detalhe ao criar o código. Se estiver incorreta, o programa não será executado.

## O que é o método `main()` em Java?

Independentemente do projeto que você deseja realizar com essa linguagem de programação e do código conciso ou extenso que você usa para isso, em Java, todo aplicativo começa com o método main. Se ele não estiver disponível, o código **não poderá ser executado**. Antes de passar para `main()`, primeiro carrega-se a máquina virtual Java (JVM) na memória e compila-se o código. Depois de concluir essas etapas, o código é passado para o método `main()` do Java para verificação e deve ser executado corretamente. Em princípio, também é possível usar vários desses métodos, embora o máximo seja um método main por classe.

## A sintaxe do método `main()` em Java

A sintaxe do método main em Java é sempre a mesma e consiste em várias partes importantes. É assim que se apresenta:

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

Esses componentes desempenham as seguintes funções:

- **public**: garante que uma classe também pode ser acedida a partir do exterior.
- **static**: declara o método como estático. Isto significa que ele pode existir sem que um objeto de uma classe específica tenha sido criado previamente.
- **void**: garante que o método main não precisa retornar um valor.
- **main**: é o nome com o qual a máquina virtual Java pode identificar o método assim que executa um programa.
- **String\[\] args**: é uma matriz na qual os argumentos da linha de comando são armazenados e recebidos.

## Os diferentes componentes e suas vantagens

Para entender melhor como funciona o método main em Java e por que todos os seus componentes são tão importantes, vamos revisá-los individualmente nas seções a seguir. Em particular, mostraremos o que acontece se **parte da assinatura estiver faltando**. Para isso, escolheremos um exemplo de código muito simples, que mostraremos com o comando Java `System.out.println`. Ficaria assim:

```bash
public class main {
	public static void main(String[] args) {
		System.out.println("Texto de ejemplo.");
	}
}
```

Se executar este código, obterá o seguinte resultado:

```bash
Texto de ejemplo.
```

### `public`

public atua como especificador de acesso e indica à máquina virtual Java **onde o programa correspondente é executado**. Existem outros modificadores de acesso, como default, private ou protected. No entanto, se os utilizar dentro do método main, receberá uma mensagem de erro:

```bash
public class main {
	private static void main(String[] args) {
		System.out.println("Texto de ejemplo.");
	}
}
```

O resultado correspondente é:

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

Esta mensagem de erro indica que não há acesso público ao método.

### `static`

O facto de o método utilizado ser estático é confirmado pela palavra-chave «static». Portanto, também pode ser utilizado **independentemente de qualquer instância de classe criada**. Se a declaração «static» for removida, o código fica assim:

```bash
public class main {
	public void main(String[] args) {
		System.out.println("Texto de ejemplo.");
	}
}
```

Neste caso, também receberá uma mensagem de erro em vez do resultado desejado:

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

### `void`

«Void» é uma palavra que especifica que o método principal **não deve retornar nenhum valor**. Como `main()` é o ponto inicial e final de um programa em Java, não seria necessário retornar nenhum valor. Este é o aspecto que o código teria sem «void»:

```bash
public class main {
	public static main(String[] args) {
		System.out.println("Texto de ejemplo.");
	}
}
```

Esta é a mensagem de erro que causa a 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`

Para cada programa em Java, a JVM procura primeiro o chamado identificador «main». Este indica **onde** a execução **deve começar e terminar**. Assim que o método main termina, a saída também termina. Portanto, esta assinatura nunca deve ser modificada ou adicionada. Se fizermos isso no nosso exemplo, o código fica assim:

```bash
public class main {
	public static void ersatzMain(String[] args) {
		System.out.println("Texto de ejemplo.");
	}
}
```

Como a JVM não consegue encontrar o identificador, ela encerrará o programa diretamente e emitirá 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`

A matriz `String[] args` corresponde à classe **java.lang.String** e contém dados armazenados como valores de cadeia. Se omitir esta especificação, o código muda:

```bash
public class main {
	public static void main() {
		System.out.println("Texto de ejemplo.");
	}
}
```

Sem o argumento, o método principal Java não pode ser executado e você receberá 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
```

## Ortografias alternativas

O exemplo de código apresentado aqui foi escrito seguindo a sintaxe mais comum. No entanto, pode adaptá-lo facilmente se desejar uma visão geral melhor. Por exemplo, é possível colocar os colchetes diretamente após «args». Ficaria assim:

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

Também pode armazenar argumentos como «varargs», ou seja, listas de argumentos variáveis:

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

Dica No nosso Guia Digital, encontrará muitos outros artigos sobre Java. Por exemplo, fizemos uma [comparação entre Java e JavaScript](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/java-vs-javascript/) e reunimos os operadores Java mais importantes.


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