La méthode main en Java

Chaque application Java commence à l'intérieur d'une méthode avec une signature très précise : public static void main(String[] args). La JVM recherche cette signature, l'appelle une fois, et votre programme s'exécute jusqu'à ce que cet appel retourne (ou que le programme soit arrêté d'une autre façon). Si une partie de la signature est incorrecte, la JVM refuse de démarrer le programme.

Vous écrivez cette ligne dans chaque exemple depuis Hello World. Ce chapitre la décortique pour que vous compreniez ce que fait chaque mot et quelle flexibilité vous avez.

La signature, mot par mot

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

• public — la JVM est « en dehors » de votre classe. Pour appeler main depuis l'extérieur, elle doit être publique. Toute visibilité plus restrictive (private, package-private) empêche la JVM d'y accéder.
• static — la JVM ne crée pas d'instance de votre classe au préalable ; elle appelle main sur la classe elle-même. main doit donc appartenir à la classe, ce que signifie static.
• void — main ne retourne rien. Le code de sortie d'un programme Java n'est pas une valeur de retour ; il est défini avec System.exit(...) ou vaut 0 par défaut en cas de fin normale.
• main — le nom littéral que recherche la JVM. Si vous l'écrivez Main, mian ou autrement, la JVM échoue au lancement avec Error: Main method not found in class ....
• String[] args — un seul paramètre, un tableau de chaînes, contenant les arguments de la ligne de commande. Le nom du paramètre n'a pas d'importance (args, argv, cmdline), seul le type compte.

Le tableau de paramètres peut aussi être écrit en varargs — String... args — ce qui est le même type pour la JVM et se comporte de façon identique :

public static void main(String... args) { ... }

Les deux formes fonctionnent. La plupart du code utilise String[] args par convention.

Les arguments de la ligne de commande

Lorsque vous exécutez un programme Java depuis le terminal, tout ce qui suit le nom de la classe devient des éléments du tableau args :

$ java Greet Ada Lovelace

Dans Greet.main, args vaut {"Ada", "Lovelace"} :

public class Greet {
  public static void main(String[] args) {
    if (args.length == 0) {
      System.out.println("Hello, stranger");
    } else {
      System.out.println("Hello, " + String.join(" ", args));
    }
  }
}

• args.length est le nombre d'arguments — 0 si aucun n'a été fourni.
• Chaque élément est toujours un String. Pour utiliser un argument numérique comme un nombre, analysez-le : int n = Integer.parseInt(args[0]);.
• Les guillemets groupent les espaces dans le shell — java Foo "hello world" place un seul élément "hello world" dans args.

Ce qui n'est pas autorisé

La signature est fixe ; de légères déviations se compilent bien mais échouent au lancement — la JVM affiche une Error: et quitte avant l'exécution de votre code :

• public void main(String[] args) — static manquant. Error: Main method is not static in class ....
• void main(String[] args) — public static manquant. Même échec « not static ».
• public static int main(String[] args) — type de retour int. Error: Main method must return a value of type void in class ....
• public static void Main(String[] args) — M majuscule, ou tout autre nom. Error: Main method not found in class ....
• public static void main(String args) — mauvais type de paramètre (un seul String, pas un tableau). Error: Main method not found in class ....

Notez que ce sont des erreurs au lancement, pas des erreurs de compilation — javac les accepte toutes. La vérification intervient quand java tente de trouver un point d'entrée.

Ce qui est autorisé et sans conséquence :

• final sur le paramètre ou la méthode : public static final void main(final String[] args).
• Les clauses throws : public static void main(String[] args) throws Exception. Parfois pratique pour des expériences rapides.
• La forme vararg : public static void main(String... args).

Plusieurs classes, un seul main

Chaque classe publique de niveau supérieur peut avoir sa propre main. Quand vous exécutez java SomeClass, la JVM cherche main dans cette classe. Un grand projet peut donc avoir des dizaines de classes avec leur propre main pour les tests ou des points d'entrée séparés ; seule celle que vous nommez sur la ligne de commande est le point d'entrée de cette exécution.

// File Greet.java
public class Greet {
  public static void main(String[] args) { System.out.println("greet"); }
}

// File Sum.java
public class Sum {
  public static void main(String[] args) {
    int total = 0;
    for (String s : args) total += Integer.parseInt(s);
    System.out.println(total);
  }
}

java Greet exécute le premier ; java Sum 1 2 3 exécute le second et affiche 6.

Terminer un programme Java

Quand main retourne normalement, le programme se termine avec le code de sortie 0. Pour quitter prématurément, ou pour définir un code de sortie non nul (signalant une erreur à l'appelant), utilisez System.exit :

if (args.length == 0) {
  System.err.println("usage: Sum <number>...");
  System.exit(1);
}

System.exit ne retourne pas — il arrête la JVM. Utilisez-le avec parcimonie ; dans les bibliothèques, c'est presque toujours le mauvais outil. Dans un petit programme en ligne de commande, c'est la façon standard de signaler « je n'ai pas pu faire mon travail. »

Un exemple complet

Prochaine étape

Cela conclut la partie sur les méthodes : vous pouvez écrire des méthodes, passer des paramètres, les surcharger, les rendre récursives, varier le nombre d'arguments, et héberger le point d'entrée qui pilote l'ensemble du programme. La partie suivante présente le conteneur plus grand dans lequel vivent les méthodes — les classes et les objets — et donne un premier aperçu du modèle orienté objet de Java.

Pratique