La méthode Java main() expliquée

Vue d’ensemble

Chaque programme a besoin d’un point de départ pour son exécution ; en ce qui concerne les programmes Java, c’est la méthode main.
Nous avons tellement l’habitude d’écrire la méthode main lors de nos sessions de programmation que nous n’accordons même plus d’attention à ses détails. Dans cet article rapide, nous allons analyser cette méthode et montrer différentes manières de l’écrire.

Signature courante

La signature de méthode main la plus courante est la suivante :

Copierpublic static void main(String[] args) { }

C’est ainsi que nous l’avons appris, c’est ainsi que l’IDE complète automatiquement le code pour nous. Mais ce n’est pas la seule forme que cette méthode peut prendre, il existe quelques variantes valides que nous pouvons utiliser et tous les développeurs ne prêtent pas attention à ce fait.

Avant de plonger dans ces signatures de méthode, revoyons la signification de chaque mot-clé de la signature courante :

• public – modificateur d’accès, ce qui signifie visibilité globale
• static – la méthode peut être accédée directement depuis la classe, nous n’avons pas besoin d’instancier un objet pour y accéder et l’utiliser
• void – signifie que cette méthode ne retourne pas de valeur
• main – le nom de la méthode, c’est l’identifiant que la JVM recherche lors de l’exécution d’un programme Java

Quant au paramètre args, il représente les valeurs reçues par la méthode. C’est ainsi que nous passons des arguments au programme lorsque nous le lançons pour la première fois.

Le paramètre args est un tableau de chaînes de caractères. Dans l’exemple suivant :

Copierjava MyMainMethodSignature hi boss

Nous exécutons un programme Java appelé MyMainMethodSignature et passons 2 arguments : hi et boss. Ces valeurs peuvent être accédées à l’intérieur de la méthode main en utilisant args[0] (qui contient la valeur « hi ») et args[1] (qui contient la valeur « boss »).

Dans l’exemple suivant, nous vérifions args pour décider si nous devons charger les paramètres de test ou de production :

Copierpublic static void main(String[] args) {
    if (args.length > 0) {
        if (args[0].equals("test")) {
            // charger les paramètres de test
        } else if (args[0].equals("production")) {
            //charger les paramètres de production
        }
    }
}

Il est toujours bon de se rappeler que les IDE peuvent également passer des arguments au programme.

Différentes façons d’écrire la méthode main()

Examinons quelques façons différentes d’écrire la méthode main. Bien qu’elles ne soient pas très courantes, elles sont des signatures valides.

Notez qu’aucune de ces variantes n’est spécifique à la méthode main, elles peuvent être utilisées avec n’importe quelle méthode Java, mais elles sont également valides dans le cadre de la méthode main.

Les crochets peuvent être placés près de String, comme dans le modèle courant, ou près de args de chaque côté :

Copierpublic static void main(String []args) { }

Copierpublic static void main(String args[]) { }

Les arguments peuvent être représentés sous forme d’arguments variables:

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

Nous pouvons même ajouter strictfp à la méthode main(), qui est utilisé pour garantir la compatibilité entre les processeurs lorsqu’on travaille avec des valeurs à virgule flottante :

Copierpublic strictfp static void main(String[] args) { }

synchronized et final sont également des mots-clés valides pour la méthode main, mais ils n’auront pas d’effet ici.

En revanche, final peut être appliqué à args pour empêcher le tableau d’être modifié :

Copierpublic static void main(final String[] args) { }

Pour conclure ces exemples, nous pouvons également écrire la méthode main avec tous les mots-clés mentionnés ci-dessus (ce que, bien sûr, vous ne ferez probablement jamais dans une application pratique) :

Copierpublic final static synchronized strictfp void main(final String[] args) { }

Avoir plusieurs méthodes main()

Nous pouvons également définir plusieurs méthodes main() dans notre application.

En fait, certaines personnes l’utilisent comme une technique de test primitive pour valider des classes individuelles (bien que des frameworks de test comme JUnit soient bien plus adaptés pour cette activité).

Pour spécifier quelle méthode main la JVM doit exécuter en tant que point d’entrée de notre application, nous utilisons le fichier MANIFEST.MF. À l’intérieur du manifeste, nous pouvons indiquer la classe principale :

CopierMain-Class: mypackage.ClassWithMainMethod

Cela est principalement utilisé lors de la création d’un fichier exécutable .jar. Nous indiquons quelle classe contient la méthode main pour démarrer l’exécution, via le fichier manifeste situé à META-INF/MANIFEST.MF (encodé en UTF-8).

Conclusion

Ce tutoriel a décrit les détails de la méthode main et certaines autres formes qu’elle peut prendre, y compris celles qui ne sont pas très courantes pour la plupart des développeurs.

Gardez à l’esprit que, bien que tous les exemples que nous avons montrés soient valides d’un point de vue syntaxique, ils servent principalement à des fins pédagogiques et, la plupart du temps, nous nous en tiendrons à la signature courante pour accomplir notre travail.