Pourquoi la méthode principale Java est-elle statique?

La signature de méthode d'une méthode Java main () est:

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

Y a-t-il une raison pour que cette méthode soit statique?

La méthode est statique car sinon il y aurait ambiguïté: quel constructeur faut-il appeler? Surtout si votre classe ressemble à ceci:

public class JavaClass{
  protected JavaClass(int x){}
  public void main(String[] args){
  }
}

La JVM doit-elle appeler new JavaClass(int)? Que doit-il passer x?

Sinon, la JVM doit-elle instancier JavaClasssans exécuter de méthode constructeur? Je pense que ce ne devrait pas être le cas, car cela mettra en cause votre classe entière - parfois, vous avez une instance qui n'a pas été initialisée, et vous devez la vérifier dans chaque méthode qui pourrait être appelée.

Il y a tout simplement trop de cas marginaux et d'ambiguïtés pour que la JVM ait du sens d'avoir à instancier une classe avant l'appel du point d'entrée. Voilà pourquoimain est statique.

Je n'ai aucune idée pourquoi mainest toujours marqué publiccependant.

Ce n'est qu'une convention. En fait, même le nom main () et les arguments passés sont purement conventionnels.

Lorsque vous exécutez java.exe (ou javaw.exe sous Windows), ce qui se passe réellement, c'est quelques appels Java Native Interface (JNI). Ces appels chargent la DLL qui est vraiment la JVM (c'est vrai - java.exe n'est PAS la JVM). JNI est l'outil que nous utilisons lorsque nous devons faire le pont entre le monde des machines virtuelles et le monde du C, C ++, etc. L'inverse est également vrai - il n'est pas possible (du moins à ma connaissance) JVM fonctionnant sans utiliser JNI.

Fondamentalement, java.exe est une application C super simple qui analyse la ligne de commande, crée un nouveau tableau de chaînes dans la JVM pour contenir ces arguments, analyse le nom de classe que vous avez spécifié comme contenant main (), utilise des appels JNI pour trouver le la méthode main () elle-même, puis invoque la méthode main (), en passant le tableau de chaînes nouvellement créé en tant que paramètre. Cela ressemble beaucoup à ce que vous faites lorsque vous utilisez la réflexion à partir de Java - il utilise simplement à la place des appels de fonction natifs nommés de manière confuse.

Il serait parfaitement légal pour vous d'écrire votre propre version de java.exe (la source est distribuée avec le JDK) et de lui faire faire quelque chose de complètement différent. En fait, c'est exactement ce que nous faisons avec toutes nos applications basées sur Java.

Chacune de nos applications Java a son propre lanceur. Nous le faisons principalement pour obtenir notre propre icône et nom de processus, mais cela est utile dans d'autres situations où nous voulons faire quelque chose en plus de l'appel principal principal () pour faire avancer les choses (par exemple, dans un cas, nous faisons Interopérabilité COM, et nous passons en fait un handle COM dans main () au lieu d'un tableau de chaînes).

Donc, long et court: la raison pour laquelle il est statique est b / c qui est pratique. La raison pour laquelle on l'appelle `` principal '' est que cela devait être quelque chose, et principal () est ce qu'ils faisaient dans l'ancien temps de C (et à cette époque, le nom de la fonction était important). Je suppose que java.exe aurait pu vous permettre de simplement spécifier un nom de méthode principale complet, au lieu de simplement la classe (java com.mycompany.Foo.someSpecialMain) - mais cela rend plus difficile pour les IDE de détecter automatiquement le ' classes lancables dans un projet.

La main()méthode dans C++, C#et Javasont statiques,
car ils peuvent ensuite être invoqués par le moteur d'exécution sans avoir à instancier aucun objet, alors le code dans le corps de main()fera le reste.

Pourquoi public static void main (String [] args)?

C'est ainsi que Java Language est conçu et Java Virtual Machine est conçu et écrit.

Spécification du langage Oracle Java

Consultez le chapitre 12 Exécution - Section 12.1.4 Invoke Test.main :

Enfin, une fois l'initialisation de la classe Test terminée (au cours de laquelle d'autres chargements, liaisons et initialisations consécutifs peuvent s'être produits), la méthode main de Test est invoquée.

La méthode main doit être déclarée publique, statique et nulle. Il doit accepter un seul argument qui est un tableau de chaînes. Cette méthode peut être déclarée comme

public static void main(String[] args)

ou

public static void main(String... args)

Spécification de la machine virtuelle Oracle Java

Consultez le Chapitre 2 Concepts du langage de programmation Java - Section 2.17 Exécution :

La machine virtuelle Java démarre l'exécution en appelant la méthode main d'une classe spécifiée et en lui passant un seul argument, qui est un tableau de chaînes. Cela entraîne le chargement de la classe spécifiée (§2.17.2), sa liaison (§2.17.3) à d'autres types qu'elle utilise et son initialisation (§2.17.4). La méthode main doit être déclarée publique, statique et nulle.

Oracle OpenJDK Source

Téléchargez et extrayez le fichier source et voyez comment JVM est écrit, consultez ../launcher/java.c, qui contient du code C natif derrière la commande java [-options] class [args...]:

/*
 * Get the application's main class.
 * ... ...
 */
if (jarfile != 0) {
    mainClassName = GetMainClassName(env, jarfile);

... ...

    mainClass = LoadClass(env, classname);
    if(mainClass == NULL) { /* exception occured */

... ...

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                                   "([Ljava/lang/String;)V");

... ...

{    /* Make sure the main method is public */
    jint mods;
    jmethodID mid;
    jobject obj = (*env)->ToReflectedMethod(env, mainClass,
                                            mainID, JNI_TRUE);

... ...

/* Build argument array */
mainArgs = NewPlatformStringArray(env, argv, argc);
if (mainArgs == NULL) {
    ReportExceptionDescription(env);
    goto leave;
}

/* Invoke main method. */
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

... ...

Imaginons simplement que static cela ne soit pas requis comme point d'entrée de l'application.

Une classe d'application ressemblerait alors à ceci:

class MyApplication {
    public MyApplication(){
        // Some init code here
    }
    public void main(String[] args){
        // real application code here
    }
}

La distinction entre code constructeur et mainméthode est nécessaire car en langage OO, un constructeur doit seulement s'assurer qu'une instance est correctement initialisée . Après l'initialisation, l'instance peut être utilisée pour le "service" souhaité. Mettre le code d'application complet dans le constructeur gâcherait cela.

Cette approche forcerait donc trois contrats différents lors de la demande:

• Il doit y avoir un constructeur par défaut. Sinon, la JVM ne saurait pas quel constructeur appeler et quels paramètres doivent être fournis.
• Il doit y avoir une mainméthode ¹ . Ok, ce n'est pas surprenant.
• La classe ne doit pas l' être abstract. Sinon, la JVM n'a pas pu l'instancier.

L' staticapproche par contre ne nécessite qu'un seul contrat:

• Il doit y avoir une mainméthode ¹ .

Ici, abstractni les constructeurs multiples n'ont d'importance.

Étant donné que Java a été conçu pour être un langage simple pour l'utilisateur, il n'est pas surprenant que le point d'entrée de l'application ait également été conçu de manière simple en utilisant un contrat et non de manière complexe en utilisant trois contrats indépendants et fragiles.

Remarque: cet argument ne concerne pas la simplicité à l'intérieur de la JVM ou à l'intérieur du JRE. Cet argument concerne la simplicité pour l' utilisateur .

Si ce n'était pas le cas, quel constructeur utiliser s'il y en a plus d'un?

Il y a plus d'informations sur l'initialisation et l'exécution des programmes Java disponibles dans la spécification du langage Java .

Avant l'appel de la méthode principale, aucun objet n'est instancié. Le fait d'avoir le mot-clé statique signifie que la méthode peut être appelée sans créer d'abord d'objets.

Car sinon, il aurait besoin d'une instance de l'objet pour être exécuté. Mais il doit être appelé à partir de zéro, sans construire l'objet au préalable, car c'est généralement la tâche de la fonction main () (bootstrap), d'analyser les arguments et de construire l'objet, généralement en utilisant ces arguments / paramètres de programme.

Permettez-moi d'expliquer ces choses d'une manière beaucoup plus simple:

public static void main(String args[])

Toutes les applications Java, à l'exception des applets, démarrent leur exécution à partir de main().

Le mot public- clé est un modificateur d'accès qui permet d'appeler le membre depuis l'extérieur de la classe.

staticest utilisé car il permet main()d'être appelé sans avoir à instancier une instance particulière de cette classe.

voidindique que main()ne renvoie aucune valeur.

Quelle est la signification de public static void main(String args[])?

1. public est un spécificateur d'accès signifiant que n'importe qui peut y accéder / l'invoquer tel que JVM (Java Virtual Machine.

2. staticpermet main()d'être appelé avant la création d'un objet de la classe. Ceci est nécessaire car il main()est appelé par la machine virtuelle Java avant la création d'objets. Comme il est statique, il peut être directement appelé via la classe.

   class demo {    
       private int length;
       private static int breadth;
       void output(){
           length=5;
           System.out.println(length);
       }
   
       static void staticOutput(){
           breadth=10; 
           System.out.println(breadth);
       }
   
       public static  void main(String args[]){
           demo d1=new demo();
           d1.output(); // Note here output() function is not static so here
           // we need to create object
           staticOutput(); // Note here staticOutput() function is  static so here
           // we needn't to create object Similar is the case with main
           /* Although:
           demo.staticOutput();  Works fine
           d1.staticOutput();  Works fine */
       }
   }

   De même, nous utilisons parfois de la statique pour les méthodes définies par l'utilisateur afin de ne pas avoir à créer d'objets.

3. voidindique que la main()méthode déclarée ne renvoie pas de valeur.

4. String[] argsspécifie le seul paramètre de la main()méthode.

   args- un paramètre qui contient un tableau d'objets de type classe String.

Des applets, des midlets, des servlets et des haricots de divers types sont construits et font ensuite appel à des méthodes de cycle de vie. L'appel de main est tout ce qui est fait à la classe principale, il n'est donc pas nécessaire qu'un état soit conservé dans un objet appelé plusieurs fois. Il est tout à fait normal d'épingler main sur une autre classe (bien que ce ne soit pas une bonne idée), ce qui gênerait l'utilisation de la classe pour créer l'objet principal.

C'est juste une convention, mais probablement plus pratique que l'alternative. Avec un main statique, tout ce que vous devez savoir pour appeler un programme Java est le nom et l'emplacement d'une classe. Si elle n'était pas statique, vous devez également savoir comment instancier cette classe, ou exiger que la classe ait un constructeur vide.

Si la méthode principale n'est pas statique, vous devrez créer un objet de votre classe principale depuis l'extérieur du programme. Comment voudriez-vous faire ça?

Lorsque vous exécutez la machine virtuelle Java (JVM) avec la javacommande,

java ClassName argument1 argument2 ...

Lorsque vous exécutez votre application, vous spécifiez son nom de classe comme argument de la commande java, comme ci-dessus

la JVM tente d'appeler la méthode principale de la classe que vous spécifiez

- à ce stade, aucun objet de la classe n'a été créé.

Déclarer mainstatique allowsla JVM pour créer un invokeprincipal de la classe.withoutinstance

revenons à la commande

ClassNameest un command-line argumentà la JVM qui lui indique quelle classe exécuter. Après le nom de classe, vous pouvez également spécifier un list of Strings(séparé par des espaces) comme arguments de ligne de commande que la machine virtuelle Java transmettra à votre application. - De tels arguments peuvent être utilisés pour spécifier des options (par exemple, un nom de fichier) pour exécuter l'application - c'est pourquoi il y a un paramètre appelé String[] argsdans le main

Références: Java ™ How To Program (Early Objects), dixième édition

Récemment, une question similaire a été publiée sur Programmers.SE

• Pourquoi une méthode principale statique en Java et C #, plutôt qu'un constructeur?

  À la recherche d'une réponse définitive d'une source primaire ou secondaire pour savoir pourquoi (notamment) Java et C # ont décidé d'avoir une méthode statique comme point d'entrée - plutôt que de représenter une instance d'application par une instance d'une Applicationclasse, le point d'entrée étant un constructeur approprié?

TL; DR une partie de la réponse acceptée est,

À Java, la raison en public static void main(String[] args)est que

1. Oison voulait
2. le code écrit par une personne expérimentée en C (pas en Java)
3. à exécuter par une personne habituée à exécuter PostScript sur NeWS

 
Pour C #, le raisonnement est pour ainsi dire transitoirement similaire . Les concepteurs de langage ont gardé la syntaxe du point d'entrée du programme familière aux programmeurs venant de Java. Comme le dit l'architecte C # Anders Hejlsberg ,

... notre approche avec C # a simplement été d'offrir une alternative ... aux programmeurs Java ...

...

Je pense que le mot-clé 'statique' fait de la méthode principale une méthode de classe, et les méthodes de classe n'en ont qu'une copie et peuvent être partagées par tous, et aussi, il ne nécessite pas d'objet pour référence. Ainsi, lorsque la classe de pilote est compilée, la méthode principale peut être invoquée. (Je suis juste au niveau alphabétique de java, désolé si je me trompe)

main () est statique car; à ce stade du cycle de vie de l'application, la pile d'application est de nature procédurale car aucun objet n'est encore instancié.

C'est une table rase. Votre application est en cours d'exécution à ce stade, même sans qu'aucun objet ne soit déclaré (rappelez-vous, il existe des modèles de codage procéduraux ET OO). En tant que développeur, vous transformez l'application en une solution orientée objet en créant des instances de vos objets et en fonction du code compilé à l'intérieur.

L'orientation objet est idéale pour des millions de raisons évidentes. Cependant, le temps est révolu où la plupart des développeurs VB utilisaient régulièrement des mots clés comme "goto" dans leur code. "goto" est une commande procédurale dans VB qui est remplacée par son homologue OO: invocation de méthode.

Vous pouvez également considérer le point d'entrée statique (principal) comme de la liberté pure. Si Java avait été suffisamment différent pour instancier un objet et vous présenter uniquement cette instance lors de l'exécution, vous n'auriez pas le choix MAIS d'écrire une application procédurale. Aussi inimaginable que cela puisse paraître pour Java, il est possible qu'il existe de nombreux scénarios qui nécessitent des approches procédurales.

C'est probablement une réponse très obscure. N'oubliez pas que "classe" n'est qu'une collection de code interrelié. "Instance" est une génération autonome isolée, vivante et respirante de cette classe.

Ce n'est qu'une convention. La JVM aurait certainement pu traiter des méthodes principales non statiques si cela avait été la convention. Après tout, vous pouvez définir un initialiseur statique sur votre classe et instancier un zillion d'objets avant d'accéder à votre méthode main ().

Le protoype public static void main(String[])est une convention définie dans le JLS :

La méthode main doit être déclarée publique, statique et nulle. Il doit spécifier un paramètre formel (§8.4.1) dont le type déclaré est un tableau de String.

Dans la spécification JVM 5.2. Démarrage de la machine virtuelle, nous pouvons lire:

La machine virtuelle Java démarre en créant une classe initiale, qui est spécifiée de manière dépendante de l'implémentation, à l'aide du chargeur de classe d'amorçage (§5.3.1). La machine virtuelle Java relie ensuite la classe initiale, l'initialise et appelle la méthode de classe publique void main (String []) . L'invocation de cette méthode entraîne toute exécution ultérieure. L'exécution des instructions de machine virtuelle Java constituant la méthode principale peut entraîner la liaison (et par conséquent la création) de classes et d'interfaces supplémentaires, ainsi que l'invocation de méthodes supplémentaires.

Chose amusante, dans la spécification JVM, il n'est pas mentionné que la méthode principale doit être statique. Mais la spécification indique également que la machine virtuelle Java effectue 2 étapes avant:

• relie la classe initiale ( 5.4. Liaison )
• l'initialise ( 5.5. Initialisation )

L'initialisation d'une classe ou d'une interface consiste à exécuter sa méthode d'initialisation de classe ou d'interface.

Dans 2.9. Méthodes spéciales :

Une méthode d'initialisation de classe ou d'interface est définie:

Une classe ou une interface possède au plus une méthode d'initialisation de classe ou d'interface et est initialisée (§5.5) en invoquant cette méthode. La méthode d'initialisation d'une classe ou d'une interface a le nom spécial <clinit>, ne prend aucun argument et est nulle.

Et une méthode d'initialisation de classe ou d'interface est différente d'une méthode d'initialisation d'instance définie comme suit:

Au niveau de la machine virtuelle Java, chaque constructeur écrit dans le langage de programmation Java (JLS §8.8) apparaît comme une méthode d'initialisation d'instance qui porte le nom spécial <init>.

Ainsi, la JVM initialise une méthode d'initialisation de classe ou d'interface et non une méthode d'initialisation d'instance qui est en fait un constructeur. Ils n'ont donc pas besoin de mentionner que la méthode principale doit être statique dans la spécification JVM car elle est impliquée par le fait qu'aucune instance n'est créée avant d'appeler la méthode principale.

Le publicmot-clé est un modificateur d'accès, qui permet au programmeur de contrôler la visibilité des membres de la classe. Lorsqu'un membre de classe est précédé de public, ce membre peut être consulté par du code en dehors de la classe dans laquelle il est déclaré.

L'opposé de publicis private, qui empêche un membre d'être utilisé par du code défini en dehors de sa classe.

Dans ce cas, main()doit être déclaré comme public, car il doit être appelé par du code en dehors de sa classe au démarrage du programme.

Le mot-clé staticpermet main()d'être appelé sans avoir à instancier une instance particulière de la classe. Ceci est nécessaire car main()est appelé par l'interpréteur Java avant la création d'objets.

Le mot-clé voidindique simplement au compilateur qui main()ne renvoie pas de valeur.

Le véritable point d'entrée de toute application est une méthode statique. Si le langage Java supportait une méthode d'instance comme "point d'entrée", alors le runtime aurait besoin de l'implémenter en interne en tant que méthode statique qui a construit une instance de l'objet suivie par l'appel de la méthode d'instance.

Avec cela à l'écart, j'examinerai la justification du choix d'une des trois options suivantes:

1. Un static void main()tel que nous le voyons aujourd'hui.
2. Une méthode d'instance void main()appelée sur un objet fraîchement construit.
3. Utiliser le constructeur d'un type comme point d'entrée (par exemple, si la classe d'entrée était appelée Program, alors l'exécution consisterait effectivement en new Program()).

Panne:

static void main()

1. Appelle le constructeur statique de la classe englobante.
2. Appelle la méthode statique main().

void main()

1. Appelle le constructeur statique de la classe englobante.
2. Construit une instance de la classe englobante en appelant efficacement new ClassName() .
3. Appelle la méthode d'instance main().

new ClassName()

1. Appelle le constructeur statique de la classe englobante.
2. Construit une instance de la classe (puis ne fait rien avec elle et retourne simplement).

Raisonnement:

Je vais aller dans l'ordre inverse pour celui-ci.

Gardez à l'esprit que l'un des objectifs de conception de Java était de mettre l'accent (exiger si possible) de bonnes pratiques de programmation orientée objet. Dans ce contexte, le constructeur d'un objet initialise l'objet, mais ne doit pas être responsable du comportement de l'objet. Par conséquent, une spécification qui a donné un point d'entrée denew ClassName() perturberait la situation des nouveaux développeurs Java en forçant une exception à la conception d'un constructeur "idéal" sur chaque application.

En créant main()une méthode d'instance, le problème ci-dessus est certainement résolu. Cependant, cela crée de la complexité en exigeant que la spécification répertorie la signature du constructeur de la classe d'entrée ainsi que la signature de la main()méthode.

En résumé, spécifier un static void main()crée une spécification avec le moins de complexité tout en respectant le principe de placement du comportement dans les méthodes . Considérant à quel point il est simple d'implémenter une main()méthode qui elle-même construit une instance d'une classe et appelle une méthode d'instance, il n'y a aucun avantage réel à spécifier main()comme méthode d'instance.

static - Lorsque la JVM appelle la méthode principale, il n'y a aucun objet qui existe pour la classe appelée, elle doit donc avoir une méthode statique pour permettre l'invocation de la classe.

Je ne sais pas si la JVM appelle la méthode principale avant que les objets ne soient instanciés ... Mais il y a une raison beaucoup plus puissante pour laquelle la méthode main () est statique ... Quand JVM appelle la méthode principale de la classe (disons , La personne). il l'invoque par " Person.main () ". Vous voyez, la JVM l'invoque par le nom de la classe. C'est pourquoi la méthode main () est censée être statique et publique pour être accessible à la JVM.

J'espère que cela a aidé. Si c'est le cas, faites-le moi savoir en commentant.

Les méthodes statiques ne nécessitent aucun objet. Il s'exécute directement donc le principal s'exécute directement.

Le mot clé statique dans la méthode principale est utilisé car aucune instanciation n'a lieu dans la méthode principale. Mais l'objet est construit plutôt que l'invocation. Par conséquent, nous utilisons le mot clé statique dans la méthode principale. Dans le contexte jvm, la mémoire est créée lorsque la classe s'y charge et tous les membres statiques sont présents dans cette mémoire. si nous faisons la statique principale maintenant, elle sera en mémoire et peut être accessible à jvm (class.main (..)) afin que nous puissions appeler la méthode main sans avoir besoin de créer un tas.

C'est juste une convention comme nous pouvons le voir ici:

La méthode doit être déclarée publique et statique , elle ne doit renvoyer aucune valeur et elle doit accepter un tableau String comme paramètre. Par défaut, le premier argument sans option est le nom de la classe à appeler. Un nom de classe complet doit être utilisé. Si l'option -jar est spécifiée, le premier argument sans option est le nom d'une archive JAR contenant des fichiers de classe et de ressources pour l'application, la classe de démarrage étant indiquée par l'en-tête du manifeste de la classe principale.

http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/java.html#description

Les mots-clés public static void signifient que l'interpréteur de la machine virtuelle Java (JVM) peut appeler la méthode principale du programme pour démarrer le programme (public) sans créer d'instance de la classe (statique), et le programme ne renvoie pas de données à l'interpréteur Java VM (nul) à la fin.

Source: Essentials, Partie 1, Leçon 2: Création d'applications

Fondamentalement, nous rendons ces MEMBRES DE DONNÉES et FONCTIONS DE MEMBRE STATIQUES qui n'exécutent aucune tâche liée à un objet. Et dans le cas de la méthode principale, nous le faisons en tant que STATIQUE car cela n'a rien à voir avec l'objet, car la méthode principale fonctionne toujours, que nous créons ou non un objet.

Toute méthode déclarée comme statique en Java appartient à la classe elle-même. Encore une fois, la méthode statique d'une classe particulière n'est accessible qu'en se référant à la classe commeClass_name.method_name();

Il n'est donc pas nécessaire d'instancier une classe avant d'accéder à une méthode statique.

Ainsi, la méthode main () est déclarée comme staticétant accessible sans créer un objet de cette classe.

Puisque nous enregistrons le programme avec le nom de la classe où la méthode principale est présente (ou d'où le programme devrait commencer son exécution, applicable pour les classes sans main()méthode () (niveau avancé)). Donc, par la manière mentionnée ci-dessus:

Class_name.method_name();

la méthode principale est accessible.

En bref, lorsque le programme est compilé, il recherche la main()méthode ayant des Stringarguments comme: main(String args[])dans la classe mentionnée (c'est-à-dire par le nom du programme), et puisqu'au début il n'a pas de portée pour instancier cette classe, donc le main () est déclarée comme statique.

De java.sun.com (il y a plus d'informations sur le site):

La méthode principale est statique pour donner à l'interpréteur Java VM un moyen de démarrer la classe sans créer d'abord une instance de la classe de contrôle. Les instances de la classe de contrôle sont créées dans la méthode principale après le démarrage du programme.

Ma compréhension a toujours été simplement que la méthode principale, comme toute méthode statique, peut être appelée sans créer d'instance de la classe associée, ce qui lui permet de s'exécuter avant toute autre chose dans le programme. S'il n'était pas statique, vous devriez instancier un objet avant de l'appeler - ce qui crée un problème de `` poulet et œuf '', car la méthode principale est généralement ce que vous utilisez pour instancier des objets au début du programme.