# Il metodo main() in Java: il punto di inizio e di fine di tutti i programmi Java

In Java il metodo `main()` è il punto di inizio e di fine di ogni programma. Solo le istruzioni che rientrano nel suo campo di validità sono considerate anche per l’esecuzione. Per questo motivo, per scrivere il codice è quindi importante tenere conto della sintassi del metodo fin nei minimi dettagli. Se non è corretta, il programma non viene eseguito.

## Cos’è il metodo `main()` in Java?

A prescindere dal progetto che vorresti realizzare con il [linguaggio di programmazione](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-programmazione-web/) e da quale codice usi, sia esso esteso o meno, all’inizio di ogni applicazione in Java c’è sempre il metodo `main()`. In sua assenza **il codice non può essere eseguito**. Prima che il codice venga passato a main(), è necessario che la macchina virtuale Java (JVM) sia caricata in memoria e che il codice sia compilato. Una volta eseguite queste operazioni, il codice passa al metodo main() per il controllo; se lo supera, viene eseguito correttamente. In linea di principio è anche possibile utilizzare più di uno di questi metodi, a patto di non inserire più di un metodo main per classe. Anche se unico, non è per forza obbligatorio; si deve ricorrere a questo metodo solo nelle classi per le quali si vuole avviare l’esecuzione.

## La sintassi del metodo `main()` in Java

La sintassi del metodo `main()` in Java è sempre uguale ed è costituita da varie parti importanti. Il metodo si presenta nel modo seguente:

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

Questi componenti svolgono le funzioni seguenti:

- **public**: assicura che sia possibile accedere a una classe anche dall’esterno.
- **static**: dichiara il metodo come statico. Può quindi esistere senza che in precedenza sia stato costruito un oggetto di una determinata classe.
- **void**: fa in modo che il metodo `main()` in Java non debba restituire nessun valore.
- **main**: questo è il nome con cui la macchina virtuale Java può identificare il metodo non appena esegue un programma.
- **String\[\] args**: si tratta di una matrice in cui vengono inseriti e ricevuti gli argomenti della riga di comando.

## I singoli componenti e la loro utilità

Per comprendere meglio come funziona il metodo `main()` in Java e perché tutti i componenti sono così importanti, nelle sezioni che seguono li analizziamo ancora uno per uno. In particolare, ti mostriamo cosa succede quando **manca un pezzo della firma**. A questo scopo utilizziamo un esempio di codice molto semplice, che generiamo con il [comando Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/comandi-java/) `System.out.println`. Si presenta come segue:

```bash
public class main {
	public static void main(String[] args) {
		System.out.println("Qui si trova il tuo testo di esempio.");
	}
}
```

Eseguendo questo codice ottieni l’output seguente:

```bash
Qui si trova il tuo testo di esempio.
```

### `public`

public funge da Access Specifier (in italiano: “modificatore di accesso) e segnala alla macchina virtuale Java **dove viene eseguito il relativo programma**. Esistono altri modificatori di accesso, come default, private o protected. Tuttavia, se vengono utilizzati all’interno del metodo main() in Java, viene generato un messaggio di errore:

```bash
public class main {
	private static void main(String[] args) {
		System.out.println("Qui si trova il tuo testo di esempio.");
	}
}
```

L’output è il seguente:

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

Questo messaggio di errore segnala che non esiste un accesso pubblico al metodo.

### `static`

Poiché il metodo usato è statico, viene confermato con la parola chiave “static”. Può essere usato anche **indipendentemente dalle eventuali istanze di classe create**. Se rimuovi la dichiarazione “static”, il codice si presenta come segue:

```bash
public class main {
    public void main(String[] args) {
    	System.out.println("Qui si trova il tuo testo di esempio.");
    }
}
```

Anche in questo caso ricevi un messaggio di errore anziché l’output desiderato:

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

### `void`

“void” è una parola chiave che definisce che il metodo main() in Java **non deve restituire valori**. Siccome `main()` è il punto di inizio e di fine di un programma in Java, restituire un valore sarebbe inutile. Senza “void” il codice si presenterebbe quindi così:

```bash
public class main {
	public static main(String[] args) {
		System.out.println("Qui si trova il tuo testo di esempio.");
	}
}
```

Questo è il messaggio di errore che provoca l’inutilizzo della parola chiave:

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

In ogni programma in Java la JVM cerca innanzitutto l’identificatore “main”, che indica **il punto in cui deve iniziare e finire l’esecuzione**. Non appena il metodo `main()` in Java è concluso, anche l’output termina. Pertanto questa firma non deve mai essere modificata o integrata. Tuttavia, se compiamo questa operazione nel nostro esempio, ne risulta il codice seguente:

```bash
public class main {
	public static void mainSostitutivo(String[] args) {
		System.out.println("Qui si trova il tuo testo di esempio.");
	}
}
```

Non trovando l’identificatore, JVM termina direttamente il programma, generando solo il messaggio di errore seguente:

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

La matrice “String\[\] args” corrisponde alla classe **java.lang.String** e contiene dati che salva come valori di stringa. Se questa indicazione non è presente, il codice cambia come segue:

```bash
public class main {
	public static void main() {
		System.out.println("Qui si trova il tuo testo di esempio.");
	}
}
```

Senza l’argomento, il metodo Java `main()` non può essere eseguito e viene nuovamente visualizzato il messaggio seguente:

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

## Notazione alternativa

L’esempio di codice mostrato qui è stato scritto con la sintassi più comune. Può comunque essere modificato facilmente per essere reso più chiaro. È possibile inserire le parentesi quadre subito dopo “args”, come segue:

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

Puoi anche inserire argomenti come “Varargs”, ovvero liste di argomenti variabili:

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

Consiglio Nella nostra Digital Guide trovi molti altri articoli su Java. Ad esempio abbiamo [confrontato Java con JavaScript](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/java-e-javascript/) e ti presentiamo gli [operatori Java](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/operatori-java/) più importanti.


This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/metodo-main-in-java/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/metodo-main-in-java/) for AI/LLM consumption.