Warum ist die Java-Hauptmethode statisch?

Die Methodensignatur einer Java main () -Methode lautet:

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

Gibt es einen Grund dafür, dass diese Methode statisch ist?

Die Methode ist statisch, da sonst Unklarheiten bestehen würden: Welcher Konstruktor sollte aufgerufen werden? Besonders wenn deine Klasse so aussieht:

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

Sollte die JVM anrufen new JavaClass(int)? Was soll es passieren x?

Wenn nicht, sollte die JVM instanziiert werden, JavaClassohne eine Konstruktormethode auszuführen? Ich denke, das sollte nicht der Fall sein, da dies Ihre gesamte Klasse in einem Sonderfall behandelt. Manchmal haben Sie eine Instanz, die nicht initialisiert wurde, und Sie müssen bei jeder Methode, die aufgerufen werden kann, danach suchen.

Es gibt einfach zu viele Randfälle und Mehrdeutigkeiten, als dass es für die JVM sinnvoll wäre, eine Klasse instanziieren zu müssen, bevor der Einstiegspunkt aufgerufen wird. Deshalb mainist statisch.

Ich habe keine Ahnung warum mainimmer markiert ist public.

Dies ist nur eine Konvention. Tatsächlich sind sogar der Name main () und die übergebenen Argumente reine Konventionen.

Wenn Sie java.exe (oder javaw.exe unter Windows) ausführen, passieren tatsächlich einige Java Native Interface (JNI) -Aufrufe. Diese Aufrufe laden die DLL, die wirklich die JVM ist (das ist richtig - java.exe ist NICHT die JVM). JNI ist das Tool, das wir verwenden, wenn wir die Welt der virtuellen Maschinen und die Welt von C, C ++ usw. überbrücken müssen. Das Gegenteil ist auch der Fall - es ist (zumindest meines Wissens) nicht möglich, tatsächlich eine zu erhalten JVM läuft ohne JNI.

Grundsätzlich ist java.exe eine supereinfache C-Anwendung, die die Befehlszeile analysiert, ein neues String-Array in der JVM erstellt, um diese Argumente zu speichern, den Klassennamen analysiert, den Sie als main () angegeben haben, und JNI-Aufrufe verwendet, um die zu finden Die main () -Methode selbst ruft dann die main () -Methode auf und übergibt das neu erstellte String-Array als Parameter. Dies ist sehr, sehr ähnlich zu dem, was Sie tun, wenn Sie die Reflexion von Java verwenden - es werden stattdessen nur verwirrend benannte native Funktionsaufrufe verwendet.

Es wäre völlig legal für Sie, eine eigene Version von java.exe zu schreiben (die Quelle wird mit dem JDK verteilt) und etwas ganz anderes tun zu lassen. Genau das machen wir mit all unseren Java-basierten Apps.

Jede unserer Java-Apps verfügt über einen eigenen Launcher. Wir tun dies in erster Linie, um unser eigenes Symbol und unseren eigenen Prozessnamen zu erhalten. In anderen Situationen, in denen wir neben dem regulären main () -Aufruf etwas tun möchten, um die Dinge in Gang zu bringen, hat sich dies jedoch als nützlich erwiesen (in einem Fall tun wir dies beispielsweise COM-Interoperabilität, und wir übergeben tatsächlich ein COM-Handle an main () anstelle eines String-Arrays).

Also, lang und kurz: Der Grund, warum es statisch ist, ist b / c, was praktisch ist. Der Grund ist es ‚main‘ genannt wird, ist , dass es etwas sein musste, und main () ist das, was sie in den alten Tagen von C hat (und in diesen Tagen, der Name der Funktion war wichtig). Ich nehme an, dass Sie mit java.exe möglicherweise nur einen vollständig qualifizierten Hauptmethodennamen anstelle der Klasse (java com.mycompany.Foo.someSpecialMain) angeben konnten. Dies erschwert es IDEs jedoch nur, die 'automatisch zu erkennen. startbare Klassen in einem Projekt.

Das main() Verfahren in C++, C#und Javaist statisch
Weil sie können dann von den Runtime - Engine aufgerufen werden , ohne dem Code in dem Körper alle Objekte dann instanziiert mit der main()der Arbeit tun.

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

So wird Java Language entworfen und Java Virtual Machine wird entworfen und geschrieben.

Oracle Java-Sprachspezifikation

Lesen Sie Kapitel 12 Ausführung - Abschnitt 12.1.4. Rufen Sie Test.main auf :

Schließlich wird nach Abschluss der Initialisierung für den Klassentest (während der möglicherweise andere nachfolgende Ladevorgänge, Verknüpfungen und Initialisierungen aufgetreten sind) die Methode main of Test aufgerufen.

Die Methode main muss als öffentlich, statisch und nichtig deklariert werden. Es muss ein einzelnes Argument akzeptieren, das ein Array von Zeichenfolgen ist. Diese Methode kann entweder deklariert werden

public static void main(String[] args)

oder

public static void main(String... args)

Oracle Java Virtual Machine-Spezifikation

Lesen Sie Kapitel 2 Konzepte der Java-Programmiersprache - Abschnitt 2.17 Ausführung :

Die virtuelle Java-Maschine startet die Ausführung, indem sie die Methode main einer bestimmten Klasse aufruft und ihr ein einzelnes Argument übergibt, bei dem es sich um ein Array von Zeichenfolgen handelt. Dadurch wird die angegebene Klasse geladen (§2.17.2), mit anderen verwendeten Typen verknüpft (§2.17.3) und initialisiert (§2.17.4). Die Methode main muss als öffentlich, statisch und nichtig deklariert werden.

Oracle OpenJDK-Quelle

Laden Sie das Quell-JAR herunter, extrahieren Sie es und sehen Sie, wie JVM geschrieben ist. Schauen Sie sich das an ../launcher/java.c, das nativen C-Code hinter dem Befehl enthält 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);

... ...

staticStellen wir uns einfach vor, dies wäre nicht als Einstiegspunkt für die Anwendung erforderlich.

Eine Anwendungsklasse würde dann folgendermaßen aussehen:

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

Die Unterscheidung zwischen Konstruktorcode und mainMethode ist notwendig, da ein Konstruktor in OO speak nur sicherstellen muss, dass eine Instanz ordnungsgemäß initialisiert wird. Nach der Initialisierung kann die Instanz für den beabsichtigten "Dienst" verwendet werden. Das Einfügen des vollständigen Anwendungscodes in den Konstruktor würde dies beeinträchtigen.

Dieser Ansatz würde dem Antrag also drei verschiedene Verträge aufzwingen:

• Es muss einen Standardkonstruktor geben. Andernfalls würde die JVM nicht wissen, welcher Konstruktor aufgerufen werden soll und welche Parameter bereitgestellt werden sollen.
• Es muss eine mainMethode ^{1 geben} . Ok, das ist nicht überraschend.
• Die Klasse darf nicht sein abstract. Andernfalls konnte die JVM dies nicht instanziieren.

Der staticAnsatz erfordert dagegen nur einen Vertrag:

• Es muss eine mainMethode ^{1 geben} .

Hier sind weder abstractnoch mehrere Konstruktoren von Bedeutung.

Da Java als einfache Sprache für den Benutzer konzipiert wurde , ist es nicht verwunderlich, dass auch der Anwendungseinstiegspunkt auf einfache Weise unter Verwendung eines Vertrags und nicht auf komplexe Weise unter Verwendung von drei unabhängigen und spröden Verträgen entworfen wurde.

Bitte beachten Sie: Bei diesem Argument geht es nicht um Einfachheit innerhalb der JVM oder innerhalb der JRE. Bei diesem Argument geht es um Einfachheit für den Benutzer .

Wenn nicht, welcher Konstruktor sollte verwendet werden, wenn es mehr als einen gibt?

Weitere Informationen zur Initialisierung und Ausführung von Java-Programmen finden Sie in der Java-Sprachspezifikation .

Bevor die Hauptmethode aufgerufen wird, werden keine Objekte instanziiert. Mit dem statischen Schlüsselwort kann die Methode aufgerufen werden, ohne zuvor Objekte zu erstellen.

Andernfalls muss eine Instanz des Objekts ausgeführt werden. Es muss jedoch von Grund auf aufgerufen werden, ohne das Objekt zuerst zu erstellen, da es normalerweise Aufgabe der main () - Funktion (Bootstrap) ist, die Argumente zu analysieren und das Objekt zu erstellen, normalerweise unter Verwendung dieser Argumente / Programmparameter.

Lassen Sie mich diese Dinge viel einfacher erklären:

public static void main(String args[])

Alle Java-Anwendungen mit Ausnahme von Applets starten ihre Ausführung ab main().

Das Schlüsselwort publicist ein Zugriffsmodifikator, mit dem das Mitglied von außerhalb der Klasse aufgerufen werden kann.

staticwird verwendet, weil es ermöglicht main(), aufgerufen zu werden, ohne eine bestimmte Instanz dieser Klasse instanziieren zu müssen.

voidgibt an, dass main()kein Wert zurückgegeben wird.

Was bedeutet das public static void main(String args[])?

1. public ist ein Zugriffsspezifizierer, der bedeutet, dass jeder darauf zugreifen / ihn aufrufen kann, z. B. JVM (Java Virtual Machine).

2. staticErmöglicht main()den Aufruf, bevor ein Objekt der Klasse erstellt wurde. Dies ist erforderlich, da main()es von der JVM aufgerufen wird, bevor Objekte erstellt werden. Da es statisch ist, kann es direkt über die Klasse aufgerufen werden.

   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 */
       }
   }

   In ähnlicher Weise verwenden wir manchmal statisch für benutzerdefinierte Methoden, damit wir keine Objekte erstellen müssen.

3. voidgibt an, dass die main()deklarierte Methode keinen Wert zurückgibt.

4. String[] argsGibt den einzigen Parameter in der main()Methode an.

   args- Ein Parameter, der ein Array von Objekten vom Klassentyp enthält String.

Applets, Midlets, Servlets und Beans verschiedener Art werden konstruiert und dann mit Lebenszyklusmethoden aufgerufen. Das Aufrufen von main ist alles, was jemals an der Hauptklasse ausgeführt wird. Es ist also nicht erforderlich, dass ein Status in einem Objekt gespeichert wird, das mehrmals aufgerufen wird. Es ist ganz normal, main einer anderen Klasse zuzuordnen (obwohl dies keine gute Idee ist), was die Verwendung der Klasse zum Erstellen des Hauptobjekts behindern würde.

Es ist nur eine Konvention, aber wahrscheinlich bequemer als die Alternative. Bei einer statischen Hauptleitung müssen Sie lediglich den Namen und den Speicherort einer Klasse kennen, um ein Java-Programm aufzurufen. Wenn es nicht statisch wäre, müssten Sie auch wissen, wie diese Klasse instanziiert wird, oder Sie müssen verlangen, dass die Klasse einen leeren Konstruktor hat.

Wenn die Hauptmethode nicht statisch wäre, müssten Sie ein Objekt Ihrer Hauptklasse von außerhalb des Programms erstellen. Wie möchten Sie das machen?

Wenn Sie die Java Virtual Machine (JVM) mit dem javaBefehl ausführen ,

java ClassName argument1 argument2 ...

Wenn Sie Ihre Anwendung ausführen, geben Sie den Klassennamen wie oben beschrieben als Argument für den Java-Befehl an

Die JVM versucht, die Hauptmethode der von Ihnen angegebenen Klasse aufzurufen

- Zu diesem Zeitpunkt wurden keine Objekte der Klasse erstellt.

mainAls statisch deklarierenallows die JVM invokeHaupt withouteines Erstellen instanceder Klasse.

Kehren wir zum Befehl zurück

ClassName ist ein command-line argument JVM, die angibt, welche Klasse ausgeführt werden soll. Nach dem Klassennamen können Sie auch ein list of Strings(durch Leerzeichen getrenntes) als Befehlszeilenargument angeben , das die JVM an Ihre Anwendung weitergibt . - Solche Argumente können verwendet werden, um Optionen (z. B. einen Dateinamen) zum Ausführen der Anwendung anzugeben. Aus diesem Grund wird String[] argsim Hauptfenster ein Parameter aufgerufen

Referenzen: Java ™ Programmieranleitung (frühe Objekte), 10. Ausgabe

Kürzlich wurde eine ähnliche Frage bei Programmers.SE veröffentlicht

• Warum eine statische Hauptmethode in Java und C # anstelle eines Konstruktors?

  Auf der Suche nach einer endgültigen Antwort von einer primären oder sekundären Quelle, warum (insbesondere) Java und C # beschlossen haben, eine statische Methode als Einstiegspunkt zu verwenden, anstatt eine Anwendungsinstanz durch eine Instanz einer ApplicationKlasse darzustellen , wobei der Einstiegspunkt eine ist geeigneter Konstruktor?

TL; DR Teil der akzeptierten Antwort ist:

In Java ist der Grund public static void main(String[] args)dafür

1. Gänschen wollte
2. der Code, der von jemandem geschrieben wurde, der Erfahrung mit C hat (nicht mit Java)
3. von jemandem ausgeführt werden, der es gewohnt ist, PostScript unter NeWS auszuführen

 
Für C # ist die Argumentation sozusagen transitiv ähnlich . Sprachdesigner haben die Programmeinstiegspunktsyntax für Programmierer aus Java vertraut gemacht. Wie C # -Architekt Anders Hejlsberg es ausdrückt ,

... unser Ansatz mit C # war einfach, Java-Programmierern eine Alternative anzubieten ...

...

Ich denke, das Schlüsselwort 'static' macht die Hauptmethode zu einer Klassenmethode, und Klassenmethoden haben nur eine Kopie davon und können von allen gemeinsam genutzt werden. Außerdem ist kein Objekt als Referenz erforderlich. Wenn die Treiberklasse kompiliert wird, kann die Hauptmethode aufgerufen werden. (Ich bin nur in der Alphabet-Ebene von Java, sorry, wenn ich falsch liege)

main () ist statisch, weil; Zu diesem Zeitpunkt im Lebenszyklus der Anwendung ist der Anwendungsstapel prozeduraler Natur, da noch keine Objekte instanziiert wurden.

Es ist eine saubere Tafel. Ihre Anwendung wird zu diesem Zeitpunkt ausgeführt, auch ohne dass Objekte deklariert wurden (denken Sie daran, dass es prozedurale UND OO-Codierungsmuster gibt). Als Entwickler verwandeln Sie die Anwendung in eine objektorientierte Lösung, indem Sie Instanzen Ihrer Objekte erstellen und von dem darin kompilierten Code abhängen.

Objektorientiert ist aus Millionen von offensichtlichen Gründen großartig. Vorbei sind jedoch die Zeiten, in denen die meisten VB-Entwickler regelmäßig Schlüsselwörter wie "goto" in ihrem Code verwendeten. "goto" ist ein prozeduraler Befehl in VB, der durch sein OO-Gegenstück ersetzt wird: Methodenaufruf.

Sie können den statischen Einstiegspunkt (main) auch als reine Freiheit betrachten. Wäre Java anders genug gewesen, um ein Objekt zu instanziieren und Ihnen beim Ausführen nur diese Instanz zu präsentieren, hätten Sie keine andere Wahl, ABER eine prozedurale App zu schreiben. So unvorstellbar es für Java auch klingen mag, es gibt viele Szenarien, die prozedurale Ansätze erfordern.

Dies ist wahrscheinlich eine sehr dunkle Antwort. Denken Sie daran, dass "Klasse" nur eine Sammlung von miteinander verbundenem Code ist. "Instanz" ist eine isolierte, lebende und atmende autonome Generation dieser Klasse.

Es ist nur eine Konvention. Die JVM könnte sich sicherlich mit nicht statischen Hauptmethoden befassen, wenn dies die Konvention gewesen wäre. Schließlich können Sie einen statischen Initialisierer für Ihre Klasse definieren und zig Objekte instanziieren, bevor Sie jemals zu Ihrer main () -Methode gelangen.

Der Prototyp public static void main(String[])ist eine im JLS definierte Konvention :

Die Methode main muss als öffentlich, statisch und nichtig deklariert werden. Es muss einen formalen Parameter (§8.4.1) angeben, dessen deklarierter Typ ein Array von String ist.

In der JVM-Spezifikation 5.2. Start der virtuellen Maschine können wir lesen:

Die Java Virtual Machine startet mit dem Erstellen einer anfänglichen Klasse, die implementierungsabhängig angegeben wird, mithilfe des Bootstrap-Klassenladeprogramms (§5.3.1). Die virtuelle Java-Maschine verknüpft dann die ursprüngliche Klasse, initialisiert sie und ruft die öffentliche Klassenmethode void main (String []) auf . Der Aufruf dieser Methode steuert die weitere Ausführung. Die Ausführung der Java Virtual Machine-Anweisungen, die die Hauptmethode bilden, kann das Verknüpfen (und folglich das Erstellen) zusätzlicher Klassen und Schnittstellen sowie den Aufruf zusätzlicher Methoden verursachen.

Lustige Sache, in der JVM-Spezifikation wird nicht erwähnt, dass die Hauptmethode statisch sein muss. Die Spezifikation besagt jedoch auch, dass die Java Virtual Machine zuvor zwei Schritte ausgeführt hat:

• verknüpft die ursprüngliche Klasse ( 5.4. Verknüpfen )
• initialisiert es ( 5.5. Initialisierung )

Die Initialisierung einer Klasse oder Schnittstelle besteht aus der Ausführung ihrer Klassen- oder Schnittstelleninitialisierungsmethode.

In 2.9. Spezielle Methoden :

Eine Klassen- oder Schnittstelleninitialisierungsmethode ist definiert:

Eine Klasse oder Schnittstelle hat höchstens eine Klassen- oder Schnittstelleninitialisierungsmethode und wird durch Aufrufen dieser Methode initialisiert (§5.5). Die Initialisierungsmethode einer Klasse oder Schnittstelle hat den speziellen Namen <clinit>, akzeptiert keine Argumente und ist ungültig.

Eine Klassen- oder Schnittstelleninitialisierungsmethode unterscheidet sich von einer Instanzinitialisierungsmethode, die wie folgt definiert ist:

Auf der Ebene der virtuellen Java-Maschine wird jeder in der Java-Programmiersprache (JLS §8.8) geschriebene Konstruktor als Instanzinitialisierungsmethode mit dem speziellen Namen angezeigt <init>.

Die JVM initialisiert also eine Klassen- oder Schnittstelleninitialisierungsmethode und keine Instanzinitialisierungsmethode, die tatsächlich ein Konstruktor ist. Sie müssen also nicht erwähnen, dass die Hauptmethode in der JVM-Spezifikation statisch sein muss, da dies durch die Tatsache impliziert wird, dass vor dem Aufruf der Hauptmethode keine Instanz erstellt wird.

Das publicSchlüsselwort ist ein Zugriffsmodifikator, mit dem der Programmierer die Sichtbarkeit von Klassenmitgliedern steuern kann. Wenn einem Klassenmitglied vorangestellt wirdpublic , kann auf dieses Mitglied durch Code außerhalb der Klasse zugegriffen werden, in der es deklariert ist.

Das Gegenteil von publicistprivate verhindert, dass ein Mitglied von Code verwendet wird, der außerhalb seiner Klasse definiert ist.

In diesem Fall main()muss als deklariert werdenpublic , da es beim Starten des Programms durch Code außerhalb seiner Klasse aufgerufen werden muss.

Mit dem Schlüsselwort statickann main()aufgerufen werden, ohne dass eine bestimmte Instanz der Klasse instanziiert werden muss. Dies ist da notwendigmain() es vom Java-Interpreter aufgerufen wird, bevor Objekte erstellt werden.

Das Schlüsselwort voidteilt dem Compiler einfach mit, dass main()kein Wert zurückgegeben wird.

Der wahre Einstiegspunkt für jede Anwendung ist eine statische Methode. Wenn die Java-Sprache eine Instanzmethode als "Einstiegspunkt" unterstützt, müsste die Laufzeit diese intern als statische Methode implementieren, die eine Instanz des Objekts erstellt und anschließend die Instanzmethode aufruft.

Nachdem dies nicht möglich ist, werde ich die Gründe für die Auswahl einer bestimmten der folgenden drei Optionen untersuchen:

1. A static void main()wie wir es heute sehen.
2. Eine Instanzmethode, void main()die für ein frisch erstelltes Objekt aufgerufen wird.
3. Verwenden des Konstruktors eines Typs als Einstiegspunkt (z. B. wenn die Eingabeklasse aufgerufen wurde Program, würde die Ausführung effektiv aus bestehen new Program()).

Nervenzusammenbruch:

static void main()

1. Ruft den statischen Konstruktor der einschließenden Klasse auf.
2. Ruft die statische Methode auf main().

void main()

1. Ruft den statischen Konstruktor der einschließenden Klasse auf.
2. Erstellt eine Instanz der einschließenden Klasse durch effektiven Aufruf new ClassName() .
3. Ruft die Instanzmethode auf main().

new ClassName()

1. Ruft den statischen Konstruktor der einschließenden Klasse auf.
2. Konstruiert eine Instanz der Klasse (macht dann nichts damit und kehrt einfach zurück).

Begründung:

Ich werde in umgekehrter Reihenfolge für diesen gehen.

Beachten Sie, dass eines der Entwurfsziele von Java darin bestand, gute objektorientierte Programmierpraktiken hervorzuheben (wenn möglich zu erfordern). In diesem Zusammenhang initialisiert der Konstruktor eines Objekts das Objekt, sollte jedoch nicht für das Verhalten des Objekts verantwortlich sein. Daher eine Spezifikation, die einen Einstiegspunkt vonnew ClassName() angibt, die Situation für neue Java-Entwickler verwirren, indem für jede Anwendung eine Ausnahme vom Entwurf eines "idealen" Konstruktors erzwungen wird.

Durch das Erstellen main()einer Instanzmethode wird das obige Problem sicherlich gelöst. Dies führt jedoch zu Komplexität, da die Spezifikation die Signatur des Konstruktors der Eintragsklasse sowie die Signatur der main()Methode auflisten muss.

Zusammenfassend lässt sich sagen, dass durch die Angabe von a static void main()eine Spezifikation mit der geringsten Komplexität erstellt wird, während das Prinzip der Platzierung von Verhalten in Methoden eingehalten wird . Wenn man bedenkt, wie einfach es ist, eine main()Methode zu implementieren , die selbst eine Instanz einer Klasse erstellt und eine Instanzmethode aufruft, hat die Angabe main()als Instanzmethode keinen wirklichen Vorteil .

statisch - Wenn die JVM die Hauptmethode aufruft, ist für die aufgerufene Klasse kein Objekt vorhanden. Daher muss eine statische Methode vorhanden sein, um den Aufruf von der Klasse zu ermöglichen.

Ich weiß nicht, ob die JVM die Hauptmethode aufruft, bevor die Objekte instanziiert werden ... Aber es gibt einen weitaus stärkeren Grund, warum die main () -Methode statisch ist ... Wenn die JVM die Hauptmethode der Klasse aufruft (z , Person). es ruft es von " Person.main () " auf. Sie sehen, die JVM ruft es unter dem Klassennamen auf. Aus diesem Grund sollte die main () -Methode statisch und öffentlich sein, damit die JVM darauf zugreifen kann.

Hoffe es hat geholfen. Wenn ja, lassen Sie es mich durch einen Kommentar wissen.

Statische Methoden erfordern kein Objekt. Es läuft direkt, also läuft main direkt.

Das statische Schlüsselwort in der Hauptmethode wird verwendet, da in der Hauptmethode keine Instanziierung stattfindet. Da das Objekt jedoch eher konstruiert als aufgerufen wird, verwenden wir in der Hauptmethode das statische Schlüsselwort. Im JVM-Kontext wird ein Speicher erstellt, wenn eine Klasse in ihn geladen wird. Und alle statischen Elemente sind in diesem Speicher vorhanden. Wenn wir die Hauptmethode jetzt statisch machen, befindet sie sich im Speicher und kann von jvm (class.main (..)) aufgerufen werden, sodass wir die Hauptmethode aufrufen können, ohne dass ein Heap erstellt werden muss.

Es ist nur eine Konvention, wie wir hier sehen können:

Die Methode muss als öffentlich und statisch deklariert sein , darf keinen Wert zurückgeben und muss ein String-Array als Parameter akzeptieren. Standardmäßig ist das erste Argument ohne Option der Name der Klasse, die aufgerufen werden soll. Es sollte ein vollständig qualifizierter Klassenname verwendet werden. Wenn die Option -jar angegeben ist, ist das erste Argument ohne Option der Name eines JAR-Archivs, das Klassen- und Ressourcendateien für die Anwendung enthält, wobei die Startklasse im Manifest-Header der Hauptklasse angegeben ist.

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

Die Schlüsselwörter public static void bedeuten, dass der Java Virtual Machine (JVM) -Interpreter die Hauptmethode des Programms aufrufen kann, um das Programm (public) zu starten, ohne eine Instanz der Klasse (static) zu erstellen, und das Programm keine Daten an den Java VM-Interpreter zurückgibt (nichtig) wenn es endet.

Quelle: Essentials, Teil 1, Lektion 2: Erstellen von Anwendungen

Grundsätzlich machen wir die DATENMITGLIEDER und MITGLIEDSFUNKTIONEN als STATISCH, die keine objektbezogene Aufgabe ausführen. Und im Fall der Hauptmethode machen wir es als STATIC, weil es nichts mit Objekt zu tun hat, da die Hauptmethode immer ausgeführt wird, ob wir ein Objekt erstellen oder nicht.

Jede in Java als statisch deklarierte Methode gehört zur Klasse selbst. Wiederum kann auf die statische Methode einer bestimmten Klasse nur unter Bezugnahme auf die Klasse like zugegriffen werdenClass_name.method_name();

Eine Klasse muss also nicht instanziiert werden, bevor auf eine statische Methode zugegriffen werden kann.

Daher wird die main () -Methode so deklariert static, dass auf sie zugegriffen werden kann, ohne ein Objekt dieser Klasse zu erstellen.

Da wir das Programm mit dem Namen der Klasse speichern, in der die Hauptmethode vorhanden ist (oder von wo aus das Programm mit der Ausführung beginnen soll, gilt dies für Klassen ohne main()Methode () (Advanced Level)). Also auf die oben erwähnte Weise:

Class_name.method_name();

Auf die Hauptmethode kann zugegriffen werden.

Kurz gesagt, wenn das Programm kompiliert wird, sucht es nach der main()Methode mit StringArgumenten wie: main(String args[])in der genannten Klasse (dh mit dem Namen des Programms), und da es zu Beginn keinen Spielraum hat, diese Klasse zu instanziieren, so ist main () Methode wird als statisch deklariert.

Von java.sun.com (es gibt weitere Informationen auf der Website):

Die Hauptmethode ist statisch, um dem Java VM-Interpreter eine Möglichkeit zu geben, die Klasse zu starten, ohne zuerst eine Instanz der Steuerungsklasse zu erstellen. Instanzen der Steuerklasse werden nach dem Start des Programms in der Hauptmethode erstellt.

Mein Verständnis war immer einfach, dass die Hauptmethode wie jede statische Methode aufgerufen werden kann, ohne eine Instanz der zugeordneten Klasse zu erstellen, sodass sie vor allen anderen Elementen im Programm ausgeführt werden kann. Wenn es nicht statisch wäre, müssten Sie ein Objekt instanziieren, bevor Sie es aufrufen. Dies führt zu einem Problem mit Hühnchen und Eiern, da die Hauptmethode im Allgemeinen die Instanziierung von Objekten zu Beginn des Programms ist.