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 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?
Réponses:
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 JavaClass
sans 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 main
est toujours marqué public
cependant.
public static void main
sert de marqueur d'un point d'entrée - un constructeur public sans paramètre ne crie pas "C'est probablement un point d'entrée!" de la même manière.
main
à appeler. Assez étrangement (pour vous), la JVM gère très bien cela.
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.
java.exe
)
static
la main()
déclaration ne vise que la convention. Le fait que ce soit «main ()» et pas autre chose est cependant réalisable.
main
non statiques et rester dans les limites du langage. Sans entendre les concepteurs, nous devrons simplement accepter d'être en désaccord. :)
La main()
méthode dans C++
, C#
et Java
sont 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.
public static void main...
, pourquoi la convention ne pourrait-elle pas être que la classe de point d'entrée d'application devrait avoir un constructeur public par défaut?
static void main
appeler? Pas un problème du tout.
static
méthodes telles que celles main
fréquemment utilisées new
pour créer un tel objet.
C'est ainsi que Java Language est conçu et Java Virtual Machine est conçu et écrit.
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)
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.
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);
... ...
main
n'était pas statique, cela signifie que l'état de l'instance de classe doit être connu et qu'il est beaucoup plus complexe à définir, comme le constructeur à utiliser en premier.
public static void main(String arguments[])
- Référence: Oak 0.2 Spec .
Runnable
. Représenter l'ensemble du processus de la même manière (c'est-à-dire avoir Runnable.Run
comme point d'entrée) a vraiment du sens en Java. Bien sûr, Runnable
lui-même est sans doute un défaut de conception, dû au fait que Java n'a pas (encore) de méthodes anonymes. Mais comme c'est déjà là…
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 main
mé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:
main
méthode 1 . Ok, ce n'est pas surprenant.abstract
. Sinon, la JVM n'a pas pu l'instancier.L' static
approche par contre ne nécessite qu'un seul contrat:
main
méthode 1 .Ici, abstract
ni 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 .
main
méthode qui est public
, static
et a la signature void main(String[])
. Je conviens que, si la méthode était une méthode d'instance, le JRE aurait un peu plus de travail mais le type de travail serait le même et la complexité ne serait pas significativement plus élevée (voir les discussions dans les commentaires de la réponse précédente). Je ne pense pas que cette différence explique la décision de rendre le point d'entrée statique, d'autant plus que les méthodes requises pour la résolution d'une méthode d'instance existent et sont facilement utilisables.
static public main(String[])
méthode est une signature et donc un contrat. Sinon, trois contrats indépendants doivent être respectés.
Runnable
. De toute évidence, Java s'attend à ce que les développeurs respectent ce contrat tout le temps, pourquoi devrait-il être trop pour le point d'entrée de l'application? Ça n'a aucun sens.
Thread
et dans le Runnable
cas où rien n'est caché à l'utilisateur, il peut clairement voir ce qui se passe et il a le changement de ne mettre en œuvre que les contrats qui lui conviennent - il a le contrôle, pas le système.
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.
static
est utilisé car il permet main()
d'être appelé sans avoir à instancier une instance particulière de cette classe.
void
indique que main()
ne renvoie aucune valeur.
Quelle est la signification de public static void main(String args[])
?
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.static
permet 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.
void
indique que la main()
méthode déclarée ne renvoie pas de valeur.
String[] args
spé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.
Lorsque vous exécutez la machine virtuelle Java (JVM) avec la java
commande,
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
main
statiqueallows
la JVM pour créer uninvoke
principal de la classe.without
instance
revenons à la commande
ClassName
est 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[] args
dans 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
À 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
Application
classe, 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
- Oison voulait
- le code écrit par une personne expérimentée en C (pas en Java)
- à 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.
main
être atteints. Et si vous incluez un constructeur statique dans la classe contenant main, cela s'exécute avant de la main
même manière.
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:
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 public
mot-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 public
is 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é static
permet
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é void
indique 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:
static void main()
tel que nous le voyons aujourd'hui.void main()
appelée sur un objet fraîchement construit.Program
, alors l'exécution consisterait effectivement en new Program()
).static void main()
main()
.void main()
new ClassName()
.main()
.new ClassName()
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.
main
. Votre raison d' main
être trop complexe pour les débutants semble incroyable. En fait, la statique main
est très déroutante pour les débutants, je doute qu'un constructeur le soit davantage. Vous dites qu'un «constructeur ne devrait pas être responsable du comportement de l'objet». Cela semble intéressant, mais je ne suis pas sûr d'être d'accord. Pourquoi pas? Qu'est-ce qui empêche cela?
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.
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 String
arguments 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.
Runnable
) en Java faire utiliser cette conception. Pourquoi l'exception (apparente) ici?