Was ist "String args []"? Parameter in der Hauptmethode Java

Ich fange gerade an, Programme in Java zu schreiben. Was bedeutet der folgende Java-Code?

public static void main(String[] args)

• Was ist String[] args?

• Wann würden Sie diese verwenden args?

Quellcode und / oder Beispiele werden abstrakten Erklärungen vorgezogen

In Java argsenthält die angegebenen Befehlszeilenargumente als Array von StringObjekten.

Mit anderen Worten, wenn Sie Ihr Programm laufen , wie java MyProgram one twodann argsenthalten["one", "two"] .

Wenn Sie den Inhalt von ausgeben möchten args, können Sie ihn einfach so durchlaufen ...

public class ArgumentExample {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

Diese sind für Befehlszeilenargumente in Java.

Mit anderen Worten, wenn Sie laufen

Java MyProgram eins zwei

Dann argsenthält:

[ "eins zwei" ]

public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}

Der Grund dafür ist, Ihre Anwendung so zu konfigurieren, dass sie auf eine bestimmte Weise ausgeführt wird, oder sie mit den benötigten Informationen zu versorgen.

Wenn Sie neu in Java sind, empfehle ich dringend, die offiziellen Java ^TM Tutorials von Oracle zu lesen .

argsenthält die Befehlszeilenargumente, die beim Aufruf an das Java-Programm übergeben werden. Zum Beispiel, wenn ich das Programm so aufrufe:

$ java MyProg -f file.txt

Dann argswird ein Array sein, das die Zeichenfolgen "-f"und enthält "file.txt".

Die folgende Antwort basiert auf meinem Verständnis und einigen Tests.

Was ist String [] args?

Ans->

String [] -> Wie wir wissen, ist dies ein einfaches String-Array.

args -> ist der Name eines Arrays, es kann alles sein (zB a, ar, argument, param, parameter), keine Probleme mit dem Compiler & ausgeführt & ich habe es auch getestet.

ZB
1) public static void main (Argument String [])

2) public static void main (Parameter String [])

Wann würden Sie diese Argumente verwenden?

Ans->

Die Hauptfunktion wird von Entwicklern sehr intelligent gestaltet. Das tatsächliche Denken ist sehr tief. Was im Grunde unter Berücksichtigung von C & C ++ basierend auf dem Kommandozeilenargument entwickelt wurde, aber heutzutage wird es von niemandem mehr verwendet.

Sache 1- Benutzer kann einen beliebigen Datentyp über die Befehlszeile eingeben. Dies kann Number oder String sein. Er muss vom Compiler akzeptiert werden. Welchen Datentyp sollten wir verwenden? siehe das Ding 2

Sache 2 - String ist der Datentyp, der alle primitiven Datentypen wie int, long, float, double, byte, shot, char in Java unterstützt. Sie können es einfach in jedem primitiven Datentyp analysieren.

ZB Das folgende Programm wurde kompiliert und ausgeführt und ich habe es auch getestet.

Wenn Eingabe -> 1 1 ist

// one class needs to have a main() method
public class HelloWorld
{
  // arguments are passed using the text field below this editor
  public static void main(String[] parameter)
  {    
System.out.println(parameter[0] + parameter[1]); // Output is 11

//Comment out below code in case of String
    System.out.println(Integer.parseInt(parameter[0]) + Integer.parseInt(parameter[1])); //Output is 2
    System.out.println(Float.parseFloat(parameter[0]) + Float.parseFloat(parameter[1])); //Output is 2.0    
    System.out.println(Long.parseLong(parameter[0]) + Long.parseLong(parameter[1])); //Output is 2    
    System.out.println(Double.parseDouble(parameter[0]) + Double.parseDouble(parameter[1])); //Output is 2.0    

  }
}

Auch wenn OP nur über das spricht String[] args, möchte ich ein vollständiges Beispiel für das gebenpublic static void main(String[] args) .

Public: ist ein Zugriffsmodifikator , der definiert, wer auf diese Methode zugreifen kann. Öffentlich bedeutet, dass jede Klasse auf diese Methode zugreifen kann (wenn andere Klassen auf diese Klasse zugreifen können).

Static: ist ein Schlüsselwort, das die klassenbezogene Sache identifiziert. Dies bedeutet, dass die angegebene Methode oder Variable nicht instanzbezogen, sondern klassenbezogen ist. Sie können darauf zugreifen, ohne die Instanz einer Klasse zu erstellen.

Void: wird verwendet, um den Rückgabetyp der Methode zu definieren. Es definiert, was die Methode zurückgeben kann. Void bedeutet, dass die Methode keinen Wert zurückgibt.

main: ist der Name der Methode. Dieser Methodenname wird von JVM als Ausgangspunkt für eine Anwendung mit nur einer bestimmten Signatur gesucht.

String[] args : ist der Parameter der Hauptmethode.

Wenn Sie sich den JDK-Quellcode ansehen (jdk-src \ j2se \ src \ share \ bin \ java.c):

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                   "([Ljava/lang/String;)V");
...
{    /* Make sure the main method is public */
...
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
    message = "Main method not public.";
    messageDest = JNI_TRUE;
    goto leave;
...

Sie können sehen, dass die Startmethode in Java benannt werden mussmain und die spezifische Signatur haben musspublic static void main(String[] args)

Der Code sagt uns auch, dass dies public static void main(String[] args)nicht behoben ist. Wenn Sie den Code in (jdk-src \ j2se \ src \ share \ bin \ java.c) in eine andere Signatur ändern, funktioniert dies, aber wenn Sie dies ändern, treten andere mögliche Probleme auf wegen der Java- Spezifikationen

Offtopic: Es ist 7 Jahre her, seit OP diese Frage gestellt hat. Ich vermute, dass OP jetzt seine eigene Frage beantworten kann.

String [] args Auf diese Weise deklarieren Sie auch ein Array von Strings in Java.

In dieser Methodensignatur wird das Array argsbeim Aufruf der Methode mit Werten gefüllt (wie die anderen Beispiele hier zeigen). Da Sie jedoch lernen, sollten Sie verstehen, dass dieses argsArray genau so ist, als hätten Sie eines in einer Methode selbst erstellt, wie in der folgenden:

public void foo() {
    String [] args = new String[2];
    args[0] = "hello";
    args[1] = "every";

    System.out.println("Output: " + args[0] + args[1]);

    // etc... the usage of 'args' here and in the main method is identical
}

Ich würde mich trennen

public static void main(String args[])

in Teilen.

"public" bedeutet, dass main () von überall aufgerufen werden kann.

"statisch" bedeutet, dass main () nicht zu einem bestimmten Objekt gehört

"void" bedeutet, dass main () keinen Wert zurückgibt

"main" ist der Name einer Funktion. main () ist etwas Besonderes, da es der Start des Programms ist.

"String []" bedeutet ein Array von String.

"args" ist der Name des Strings [] (im Hauptteil von main ()). "args" ist nichts Besonderes; Sie könnten es auch anders nennen und das Programm würde genauso funktionieren.

• String[] argsist eine Sammlung von Strings, die durch ein Leerzeichen getrennt sind und in das Programm auf dem Terminal eingegeben werden können. Mehr als einmal wird der Anfänger diese Variable nicht verwenden, aber sie ist immer für alle Fälle da.

Wenn Sie Ihren Code fertiggestellt haben, verwandeln Sie ihn in eine Datei mit der Erweiterung .java, die durch Doppelklick ausgeführt werden kann, aber auch in einer Konsole (Terminal auf einem Mac, cmd.exe unter Windows), die der Benutzer ausführen kann viele Dinge. Eine Sache ist, dass sie Konsolennachrichten (System.out.print oder System.out.println) sehen können, die sie nicht sehen können, wenn sie doppelklicken. Sie können auch Parameter angeben, sodass Sie normalerweise die Zeile verwenden würden

java -jar MyCode.jar

nach dem Navigieren zum Ordner des Programms mit

cd C:My/Code/Location

auf Windows oder

cd My/Code/Location

auf dem Mac (beachten Sie, dass der Mac weniger umständlich ist), um Code auszuführen, aber um Parameter anzugeben, die Sie verwenden würden

java -jar MyCode.jar parameter1 parameter2

Mit diesen im args-Array gespeicherten Parametern, die Sie in Ihrem Programm verwenden können, möchten Sie dem Benutzer ermöglichen, spezielle Parameter zu steuern, z. B. welche Datei verwendet werden soll oder wie viel Speicher das Programm haben kann. Wenn Sie wissen möchten, wie ein Array verwendet wird, können Sie wahrscheinlich ein Thema auf dieser Site finden oder es einfach googeln. Beachten Sie, dass eine beliebige Anzahl von Parametern verwendet werden kann.

Erklärung in einfacher Laiensprache.

Die Hauptmethode erwartet von uns einige Argumente, wenn wir unsere JVM auf den Klassennamen richten. Angenommen, Ihr Dateiname lautet Try.java. Um dies in der Eingabeaufforderung auszuführen, schreiben Sie "javac Try.java" zum Kompilieren, gefolgt von "java Try" zum Ausführen. Angenommen, Sie schreiben nicht einfach "Java Try", sondern "Java Try 1". Hier haben Sie ein Argument "1" übergeben. Dies wird von Ihrer Hauptmethode übernommen, auch wenn Sie sie nicht in Ihrem Code verwenden.

Wenn Sie überprüfen möchten, ob Ihre Hauptmethode tatsächlich das Argument "1" verwendet hat oder nicht. Geben Sie einfach in Ihre Hauptmethode Folgendes ein:

for(int i = 0; i < args.length; i++) {
        System.out.println("Argument is: "+args[i]);
    }

Ich denke, die obigen Antworten decken dies ziemlich gut ab. Es String args[]handelt sich lediglich um eine Reihe von Zeichenfolgenargumenten, die Sie an Ihre Anwendung übergeben können, wenn Sie sie ausführen. Zum Abschluss mainmöchte ich hinzufügen, dass es auch gültig ist, den an die Methode übergebenen Methodenparameter als Variablenargument (varargs) vom Typ String zu definieren:

public static void main (String... args)

Mit anderen Worten, die mainMethode muss entweder ein String-Array ( String args[]) oder varargs ( String... args) als Methodenargument akzeptieren . Und es gibt auch keine Magie mit dem Namen args. Sie können genauso gut schreiben argumentsoder sogar freddiefujiwarawie unten gezeigt, z.

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Wenn eine Java-Klasse über die Konsole ausgeführt wird, wird die Hauptmethode aufgerufen. Dazu muss die Definition dieser Hauptmethode sein

public static void main(String [])

Die Tatsache, dass dieses String-Array als args bezeichnet wird, ist eine Standardkonvention, jedoch nicht unbedingt erforderlich. Sie würden dieses Array in der Befehlszeile füllen, wenn Sie Ihr Programm aufrufen

java MyClass a b c

Diese werden häufig verwendet, um Optionen Ihres Programms zu definieren, z. B. Dateien, in die geschrieben oder aus denen gelesen werden soll.

in public static void main (String args []) args ist ein Array von Konsolenzeilenargumenten, deren Datentyp String ist. In diesem Array können Sie verschiedene Zeichenfolgenargumente speichern, indem Sie sie wie unten gezeigt in der Befehlszeile aufrufen: java myProgram Shaan Royal, dann werden Shaan und Royal im Array gespeichert als arg [0] = "Shaan"; arg [1] = "Royal"; Sie können dies manuell auch innerhalb des Programms tun, wenn Sie sie nicht über die Befehlszeile aufrufen.

Der Stil dataType[] arrayRefVarwird bevorzugt. Der Stil dataType arrayRefVar[]stammt aus der C / C ++ - Sprache und wurde in Java übernommen, um C / C ++ - Programmierern gerecht zu werden.

Der String[] argsParameter ist ein Array von Zeichenfolgen, die als Parameter übergeben werden, wenn Sie Ihre Anwendung über die Befehlszeile im Betriebssystem ausführen.

Stellen Sie sich vor, Sie haben eine myApp.jarJava-Anwendung kompiliert und gepackt . Sie können Ihre App natürlich durch Doppelklicken im Betriebssystem ausführen, aber Sie können sie auch über die Befehlszeile ausführen, z. B. (z. B. unter Linux):

user@computer:~$ java -jar myApp.jar

Wenn Sie Ihre Anwendung aufrufen und einige Parameter übergeben, z.

user@computer:~$ java -jar myApp.jar update notify

Der java -jarBefehl übergibt Ihre Zeichenfolgen updateund notifyIhre public static void main()Methode.

Sie können dann etwas tun wie:

System.out.println(args[0]); //Which will print 'update'
System.out.println(args[1]); //Which will print 'notify'

Zusätzlich zu allen vorherigen Kommentaren.

public static void main(String[] args) 

kann geschrieben werden als

 public static void main(String...arg)

oder

 public static void main(String...strings)