Ik ben net begonnen met het schrijven van programma’s in Java. Wat betekent de volgende Java-code?
public static void main(String[] args)
-
Wat is
String[] args? -
Wanneer zou je deze
argsgebruiken?
Broncode en/of voorbeelden hebben de voorkeur boven abstracte uitleg
Antwoord 1, autoriteit 100%
In Java bevat argshet meegeleverde commando -regelargumentenals een array van String-objecten.
Met andere woorden, als u uw programma uitvoert als java MyProgram one two, dan zal args["one", "two"].
Als je de inhoud van argswilt weergeven, kun je ze zo doorlopen…
public class ArgumentExample {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
Antwoord 2, autoriteit 37%
Die zijn voor opdrachtregelargumenten in Java.
Met andere woorden, als je rent
java MijnProgramma één twee
Dan bevat args:
[ “één”, “twee” ]
public static void main(String [] args) {
String one = args[0]; //=="one"
String two = args[1]; //=="two"
}
De reden hiervoor is om uw toepassing zo te configureren dat deze op een bepaalde manier wordt uitgevoerd of om deze te voorzien van een stukje informatie dat het nodig heeft.
Als Java nieuw voor u is, raad ik u ten zeerste aan de officiële Java™ van Oracle door te lezen. Zelfstudies.
Antwoord 3, autoriteit 14%
argsbevat de opdrachtregelargumenten die bij het aanroepen aan het Java-programma zijn doorgegeven. Als ik het programma bijvoorbeeld als volgt aanroep:
$ java MyProg -f file.txt
Dan zal argseen array zijn met de strings "-f"en "file.txt".
Antwoord 4, autoriteit 7%
Het volgende antwoord is gebaseerd op mijn begrip & wat testen.
Wat is String[]-args?
Antwoord >
String[]-> Zoals we weten is dit een eenvoudige String-array.
argumenten-> is de naam van een array het kan van alles zijn (bijv. a, ar, argument, param, parameter) geen problemen met compiler & uitgevoerd & Ik heb het ook getest.
Bijvoorbeeld
1)public static void main(String[] argument)
2)public static void main(String[] parameter)
Wanneer zou je deze argumenten gebruiken?
Ant->
De hoofdfunctie is zeer intelligent ontworpen door ontwikkelaars. Echt denken is heel diep.
Die in principe is ontwikkeld onder overweging van C & C++ gebaseerd op Command line argument maar tegenwoordig gebruikt niemand het meer.
Ding 1-De gebruiker kan elk type gegevens invoeren vanaf de opdrachtregel, dit kan Nummer of String zijn & nodig om het door de compiler te accepteren welk datatype moeten we gebruiken? zie het ding 2
Thing 2-String is het datatype dat alle primitieve datatypes ondersteunt, zoals int, long, float, double, byte, shot, char in Java. Je kunt het gemakkelijk ontleden in elk primitief datatype.
BijvoorbeeldHet volgende programma is samengesteld & uitgevoerd & Ik heb het ook getest.
Als invoer -> 1 1
// 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
}
}
Antwoord 5, autoriteit 4%
Ook al heeft OP het alleen over de String[] args, ik wil een compleet voorbeeld geven van de public static void main(String[] args).
Public: is een Access Modifier, die bepaalt wie toegang heeft tot deze methode. Openbaar betekent dat deze methode toegankelijk is voor elke klasse (als andere klassen toegang hebben tot deze klasse).
Static: is een sleutelwoord dat het klassegerelateerde ding identificeert. Dit betekent dat de gegeven methode of variabele niet instantie-gerelateerd is, maar klasse-gerelateerd. Het is toegankelijk zonder de instantie van een klasse te maken.
Void: wordt gebruikt om het retourtype van de methode te definiëren. Het definieert wat de methode kan retourneren. Void betekent dat de methode geen waarde retourneert.
main: is de naam van de methode. Deze methodenaam wordt door JVM gezocht als startpunt voor een toepassing met alleen een bepaalde handtekening.
String[] args: is de parameter voor de hoofdmethode.
Als je de JDK-broncode (jdk-src\j2se\src\share\bin\java.c) bekijkt:
/* 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;
...
Je kunt zien dat de startmethodein java moet zijn met de naam mainen moet de specifieke handtekening hebben public static void main(String[] args)
De code vertelt ons ook dat de public static void main(String[] args)niet is opgelost, als je de code wijzigt in (jdk-src\j2se\src\share\bin\ java.c) naar een andere handtekening, zal het werken, maar als u dit wijzigt, krijgt u andere mogelijke problemen vanwege de java specificaties
Offtopic: Het is 7 jaar geleden dat op de vraag deze vraag stelde, mijn gok is dat op nu zijn eigen vraag kan beantwoorden.
Antwoord 6, Autoriteit 4%
Ik zou het uitbreken
public static void main(String args[])
in delen.
“openbaar” betekent dat MAIN () overal kan worden genoemd.
“Statisch” betekent dat Main () niet behoort tot een specifiek object
“ongeldig” betekent dat MAIN () geen waarde
retourneert
“hoofd” is de naam van een functie. Main () is speciaal omdat het de start van het programma is.
“String []” betekent een reeks reeks.
“args” is de naam van de tekenreeks [] (in het hoofdgedeelte ()). “Args” is niet speciaal; Je zou het nog iets anders kunnen noemen en het programma zou hetzelfde werken.
String[] argsis een verzameling snaren, gescheiden door een ruimte, die kan worden ingetypt in het programma op de terminal. Meer keren dan niet, de beginner gaat deze variabele niet gebruiken, maar het is er altijd voor het geval dat.
Antwoord 7, Autoriteit 3%
String[] argsIs ook hoe u een scala aan snaren in Java declareert.
In deze methode handtekening wordt de array argsgevuld met waarden wanneer de methode wordt genoemd (zoals de andere voorbeelden hier laten zien). Sinds je leert, is het de moeite waard om te begrijpen dat dit argsarray net als je een zelf hebt gemaakt in een methode, zoals in dit:
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
}
Antwoord 8, autoriteit 3%
Als u klaar bent met uw code, verandert u deze in een bestand met de extensie .java, dat kan worden uitgevoerd door erop te dubbelklikken, maar ook in een console (terminal op een mac, cmd.exe op Windows) waarmee u de gebruiker doet veel dingen. Eén ding is dat ze consoleberichten (System.out.print of System.out.println) kunnen zien die ze niet kunnen zien als ze dubbelklikken. Een ander ding dat ze kunnen doen is parameters specificeren, dus normaal gesproken zou je de regel
. gebruiken
java -jar MyCode.jar
na het navigeren naar de map van het programma met
cd C:My/Code/Location
op vensters of
cd My/Code/Location
op Mac (merk op dat mac minder onhandig is) om code uit te voeren, maar om parameters op te geven die u zou gebruiken
java -jar MyCode.jar parameter1 parameter2
Deze parameters die zijn opgeslagen in de args-array, die u in uw programma kunt gebruiken, is dat u de gebruiker speciale parameters wilt laten regelen, zoals welk bestand moet worden gebruikt of hoeveel geheugen het programma kan hebben. Als je wilt weten hoe je een array moet gebruiken, kun je waarschijnlijk een onderwerp op deze site vinden of gewoon googlen. Merk op dat een willekeurig aantal parameters kan worden gebruikt.
Antwoord 9, autoriteit 3%
Uitleg in eenvoudige lekentaal.
De hoofdmethode verwacht dat we een aantal argumenten bieden wanneer we onze JVM naar de klasnaam sturen. Dat betekent, stel dat uw bestandsnaam PRY.JAVA is, nu om dit in de opdrachtprompt uit te voeren die u schrijft “Javac Try.java” om te compileren gevolgd door “Java Probeer” om uit te voeren. Stel nu in plaats van gewoon te schrijven “Java Probeer” je “Java Probeer 1” schrijft. Hier heb je een argument gepasseerd “1”. Dit wordt door uw hoofdmethode genomen, zelfs als u het niet in uw code gebruikt.
Als u wilt controleren of uw hoofdmethode het argument “1” daadwerkelijk heeft genomen of niet. Gewoon, in uw hoofdmethode type het volgende:
for(int i = 0; i < args.length; i++) {
System.out.println("Argument is: "+args[i]);
}
Antwoord 10, Autoriteit 2%
Ik denk dat het vrij goed is gedekt door de bovenstaande antwoorden die String args[]gewoon een reeks stringargumenten is die u kunt doorgeven naar uw toepassing wanneer u het uitvoert. Voor voltooiing kan ik eraan toevoegen dat het ook geldig is om de methodeparameter doorgegeven aan de main-methode te definiëren als een variabele argument (varargs) van Type String:
public static void main (String... args)
Met andere woorden, de mainmethode moet een stringarray accepteren (String args[]) of varargs (String... args) als een methodeargument. En er is geen magie met de naam argsook. U kunt net zo goed schrijven argumentsof zelfs freddiefujiwarazoals getoond in de onderstaande b.vs.:
public static void main (String[] arguments)
public static void main (String[] freddiefujiwara)
Antwoord 11, Autoriteit 2%
Wanneer een java-klasse wordt uitgevoerd vanaf de console, is de hoofdmethode wat wordt aangeroepen. Om dit te laten gebeuren, moet de definitie van deze hoofdmethode zijn
public static void main(String [])
Het feit dat deze stringarray args wordt genoemd, is een standaardconventie, maar niet strikt vereist. U zou deze array op de opdrachtregel invullen wanneer u uw programma aanroept
java MyClass a b c
Deze worden vaak gebruikt om opties van uw programma te definiëren, bijvoorbeeld bestanden om naar te schrijven of van te lezen.
Antwoord 12, autoriteit 2%
in
public static void main(String args[])
args is een array van consoleregelargumenten waarvan het gegevenstype String is.
in deze array kunt u verschillende stringargumenten opslaan door ze op de opdrachtregel aan te roepen, zoals hieronder weergegeven:
java myProgram Shaan Royal
dan worden Shaan en Royal in de array opgeslagen als
arg[0]=”Shan”;
arg[1]=”Koninklijk”;
je kunt dit ook handmatig doen in het programma, als je ze niet aanroept op de opdrachtregel.
Antwoord 13
De stijl dataType[] arrayRefVarheeft de voorkeur. De stijl dataType arrayRefVar[]komt uit de C/C++-taal en werd in Java overgenomen om C/C++-programmeurs tegemoet te komen.
Antwoord 14
In aanvulling op alle eerdere opmerkingen.
public static void main(String[] args)
kan worden geschreven als
public static void main(String...arg)
of
public static void main(String...strings)
Antwoord 15
String[] argsbetekent een reeks van reeksen tekens (Strings) die worden doorgegeven aan de “hoofd”-functie. Dit gebeurt wanneer een programma wordt uitgevoerd.
Voorbeeld wanneer u een Java-programma uitvoert via de opdrachtregel:
java MyProgram This is just a test
Daarom zal de array opslaan: ["This", "is", "just", "a", "test"]
Antwoord 16
De parameter String[] argsis een array van Strings die als parameters worden doorgegeven wanneer u uw toepassing uitvoert via de opdrachtregel in het besturingssysteem.
Stel je dus voor dat je een myApp.jarJava-toepassing hebt gecompileerd en verpakt. U kunt uw app natuurlijk uitvoeren door erop te dubbelklikken in het besturingssysteem, maar u kunt het ook uitvoeren via de opdrachtregel, zoals (in Linux bijvoorbeeld):
user@computer:~$ java -jar myApp.jar
Wanneer u uw applicatie aanroept en enkele parameters doorgeeft, zoals:
user@computer:~$ java -jar myApp.jar update notify
Het java -jarcommando zal je Strings updateen notifydoorgeven aan je public static void main()methode.
Je kunt dan zoiets doen als:
System.out.println(args[0]); //Which will print 'update'
System.out.println(args[1]); //Which will print 'notify'
Antwoord 17
U kunt ook de onderstaande syntaxis gebruiken.
public static void main(String... args)
hier ellips, d.w.z. drie punten na het gegevenstype Stringspecificeert nul of meerdere argumenten (variabel aantal argumenten).
Antwoord 18
probeer dit:
System.getProperties().getProperty("sun.java.command",
System.getProperties().getProperty("sun.rt.javaCommand"));