# Java main() method : le point d’entrée et de sortie de tous les programmes Java

Java `main()` method correspond au point d’entrée et au point de sortie de chaque programme. Lors de l’exécution, seules les instructions qui sont comprises dans son domaine de validité entrent en ligne de compte. Il est par conséquent tout aussi important de respecter la syntaxe de la méthode à la lettre lors de la création du code. Si elle est incorrecte, le programme ne pourra pas s’exécuter.

## Qu’est-ce que Java `main()` method ?

Quel que soit le projet que vous souhaitez concrétiser à l’aide du langage de programmation ou la longueur du code que vous souhaitez utiliser à cet effet : vous rencontrerez toujours Java `main()` method au début de toute application. En son absence, **le code ne peut pas être exécuté**. Avant de le soumettre à `main()`, la machine virtuelle Java (en anglais *Java virtual machine*, abr. JVM) est chargée en mémoire et le code est compilé. Une fois ces étapes terminées, le code est soumis à la méthode Java `main ()` à des fins de contrôle et sera exécuté correctement, selon toute espérance. En principe, il est également possible d’utiliser plusieurs de ces méthodes, avec au maximum une méthode main par classe.

## La syntaxe de la méthode `main()` en Java

La syntaxe de la méthode `main()` en Java est toujours la même et se compose de plusieurs parties importantes. La méthode s’apparente à ceci :

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

Ces composantes remplissent les fonctions suivantes :

- **public** : garantit qu’une classe est également accessible de l’extérieur.
- **static** : la méthode est déclarée statique. Cela lui permet d’exister sans qu’un objet d’une classe particulière ne soit constitué à l’avance.
- **void** : garantit que la méthode `main()` n’a pas besoin de retourner une valeur en Java . -**main** : il s’agit du nom qui permet à la machine virtuelle Java d’identifier la méthode dès qu’elle exécute un programme.
- **String\[\] args** : il s’agit ici d’un tableau où l’on peut renseigner les arguments de ligne de commande et les transmettre.

## Les composants individuels et leur utilité

Pour mieux comprendre comment fonctionne la méthode `main()` en Java et pourquoi toutes les composantes sont si importantes, nous les passons individuellement en revue dans les sections suivantes. Ce faisant, nous souhaitons surtout vous montrer ce qui se passe quand **une partie de la signature fait défaut**. Nous partons d’un exemple de code très simple, que nous sortons avec la commande Java `system.out.println`. Il se présente comme suit :

```bash
public class main {
	public static void main(String[] args) {
		System.out.println("Votre exemple de texte apparait ici.");
	}
}
```

Lorsque vous exécutez ce code, vous obtenez le résultat suivant :

```bash
Votre exemple de texte apparait ici.
```

### `public`

« public » agit en tant que spécificateur d’accès et signale à la machine virtuelle Java **où le programme correspondant est exécuté**. Il existe d’autres modificateurs d’accès tels que « default », « private » ou « protected ». Cependant, un message d’erreur va apparaitre si vous les utilisez dans Java `main()` method :

```bash
public class main {
	private static void main(String[] args) {
		System.out.println("Votre exemple de texte apparait ici.");
	}
}
```

Le résultat correspond à :

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

Ce message d’erreur indique l’absence d’accès public à la méthode.

### `static`

Le mot-clé « static » confirme que la méthode utilisée est statique. Il peut également être utilisé **indépendamment de toute instance de classe créée**. Si vous supprimez la déclaration comme « static », le code ressemble à ceci :

```bash
public class main {
    public void main(String[] args) {
    	System.out.println("Votre exemple de texte apparait ici.");
    }
}
```

Ici aussi, un message d’erreur se présente au lieu de la sortie souhaitée :

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

### `void`

« void » est un mot-clé qui spécifie que Java main() method **ne doit pas retourner de valeurs**. `main()` étant le point d’entrée et de sortie d’un programme en Java, la lecture serait inutile. Le code se présenterait donc comme suit en l’absence de « void » :

```bash
public class main {
	public static main(String[] args) {
		System.out.println("Votre exemple de texte apparait ici.");
	}
}
```

Ceci est le message d’erreur déclenché par l’omission du mot-clé :

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

Pour chaque programme en Java, la JVM recherche d’abord l’identifiant « main ». Cela indique **où l’exécution doit commencer et se terminer**. Une fois Java main() method terminée, la sortie est également terminée. Par conséquent, cette signature ne doit jamais être modifiée ni complétée. Si nous procédons toutefois ainsi dans notre exemple, le code ressemble à ceci :

```bash
public class main {
	public static void remplaceMain(String[] args) {
		System.out.println("Votre exemple de texte apparait ici.");
	}
}
```

Comme la JVM ne peut pas retrouver l’identifiant, elle quitte le programme directement et émet uniquement le message d’erreur suivant :

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

Le tableau « String\[\] args » correspond à la classe **java.lang.String** et contient des données stockées sous forme de valeurs de chaîne. Si vous ne le spécifiez pas, ceci modifie le code comme suit :

```bash
public class main {
	public static void main() {
		System.out.println("Votre exemple de texte apparait ici.");
	}
}
```

Sans l’argument, il est impossible d’exécuter la méthode `main()` en Java et vous observez à nouveau le message d’erreur suivant :

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

## Notation alternative

L’exemple de code exposé ici a été écrit selon la syntaxe la plus courante. Vous pouvez cependant la modifier légèrement si vous en attendez une meilleure vue d’ensemble. Il est ainsi possible de placer les crochets directement derrière « args ». Cela se présente comme suit :

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

Vous pouvez également renseigner des arguments comme « varargs », c’est-à-dire comme des listes d’arguments variables :

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

Conseil Notre Digital Guide vous propose de nombreux autres articles sur le thème de Java. Nous avons ainsi [comparé Java avec JavaScript](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-vs-javascript/) et vous présentons les principaux opérateurs Java.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-main-method/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-main-method/) for AI/LLM consumption.