Använda kommandoradsargument i en Java-applikation

Kommandoradsargument kan vara ett sätt att ange konfigurationsegenskaper för ett program, och Java är inte annorlunda. Istället för att klicka på en applikationsikon från operativsystemet kan du köra Java-applikationen från ett terminalfönster. Tillsammans med applikationsnamnet kan ett antal argument följa som sedan skickas till applikationens startpunkt (dvs huvudmetoden, i fallet med Java).

Till exempel har NetBeans ett antal startparametrar som kan skickas till applikationen när det körs från ett terminalfönster (t.ex..,

anger en version av JDK som ska användas istället för standard JDK som är associerad med NetBeans-applikationen).

Huvudmetoden

Låt oss undersöka huvudmetoden för att se var argumenten som skickas till en applikation visas:

Kommandoradsargumenten finns i

kallad

Låt oss till exempel överväga en applikation som heter

vars enda åtgärd är att skriva ut kommandoradsargumenten som skickas till den:

public class CommandLineArgs

   public static void main (String [] args) 
// kontrollera om strängmatrisen är tom
if (args.length == 0)

System.out.println ("Det fanns inga kommandoradsargument!");

       // För varje sträng i strängfältet
// skriva ut strängen.
för (Strängargument: args)

System.out.println (argument);

Syntax för kommandoradsargument

Java Runtime Engine (JRE) förväntar sig att argument ska skickas efter en viss syntax, som så:

java Programnamn värde1 värde2

Ovan kallar "java" till JRE, som följs av namnet på det program du ringer. Dessa följs av alla argument till programmet. Det finns ingen begränsning för antalet argument ett program kan ta, men ordningen är kritisk. JRE skickar argumenten i den ordning de visas på kommandoraden. Tänk till exempel det här kodavsnittet ovan:

public class CommandLineArgs2

   public static void main (String [] args) 
if (args.length == 0)

System.out.println ("Det fanns inga kommandoradsargument!");

När argument överförs till ett Java-program är args [0] det första elementet i matrisen (värde1 ovan), args [1] är det andra elementet (värde2), och så vidare. Koden args.length () definierar längden på matrisen.

Passerar kommandoradsargument

I NetBeans kan vi skicka kommandoradsargument utan att behöva bygga applikationen och köra den från ett terminalfönster. Så här anger du kommandoradsargumenten:

Högerklicka på projektmappen i
```
projekt
```
fönster.
Välj den
```
Egenskaper
```
alternativet att öppna
```
Projektegenskaper
```
fönster.
I
```
kategorier
```
lista till höger, välj
```
Springa
```
I
```
Argument
```
textbox som visas, ange de kommandoradsargument som du vill överföra till applikationen. Till exempel, om vi går in
```
Apple banan morot
```
i
```
Argument
```
textbox och kör
```
CommandLineArgs
```
programmet ovan, kommer vi att få utdata:

Analysera kommandoradsargumenten

Normalt skickas ett kommandoradsargument med viss information om vad man ska göra med värdet som skickas. Argumentet som informerar applikationen vad argumentet är för har vanligtvis en bindestreck eller två före dess namn. Exempelvis är NetBeans-exemplet för startparametern som anger JDK-banan

Detta betyder att du måste analysera kommandoradsargumenten för att ta reda på vad du ska göra med värdena. Det finns flera Java-kommandoradsramar för att analysera kommandoradsargument. Eller så kan du skriva en enkel kommandorads-tolkare om de argument du behöver för att inte är så många:

Koden ovan skriver antingen ut argumenten eller lägger till dem om de är heltal. Till exempel skulle detta kommandoradsargument lägga till siffrorna:

java CommandLineArgs-nummer 11 22 33 44

Vetenskap