Opdrachtregelargumenten gebruiken in een Java-toepassing

Opdrachtregelargumenten kunnen een manier zijn om configuratie-eigenschappen voor een toepassing op te geven, en Java is niet anders. In plaats van te klikken op een toepassingspictogram vanuit het besturingssysteem, kunt u de Java-toepassing uitvoeren vanuit een terminalvenster. Samen met de naam van de toepassing kunnen een aantal argumenten volgen die vervolgens worden doorgegeven aan het startpunt van de toepassing (d.w.z. de belangrijkste methode in het geval van Java).

NetBeans heeft bijvoorbeeld een aantal opstartparameters die kunnen worden doorgegeven aan de toepassing wanneer deze wordt uitgevoerd vanuit een terminalvenster (bijv..,

specificeert een versie van de JDK die moet worden gebruikt in plaats van de standaard JDK die is gekoppeld aan de NetBeans-toepassing).

De belangrijkste methode

Laten we de belangrijkste methode bekijken om te zien waar de argumenten die aan een toepassing zijn doorgegeven verschijnen:

De opdrachtregelargumenten zijn te vinden in de

riep

Laten we bijvoorbeeld eens kijken naar een toepassing die wordt genoemd

wiens enige actie is het afdrukken van de opdrachtregelargumenten die eraan zijn doorgegeven:

openbare klasse CommandLineArgs

   public static void main (String [] args) 
// controleer of de reeks String leeg is
if (args.length == 0)

System.out.println ("Er zijn geen opdrachtregelargumenten doorgegeven!");

       // Voor elke tekenreeks in de reeks String
// print de string uit.
voor (Stringargument: args)

System.out.println (argument);

Syntaxis van opdrachtregelargumenten

De Java Runtime Engine (JRE) verwacht dat argumenten worden doorgegeven na een bepaalde syntaxis, zoals:

java ProgramName waarde1 waarde2

Hierboven roept "java" de JRE op, gevolgd door de naam van het programma dat u aanroept. Deze worden gevolgd door eventuele argumenten voor het programma. Er is geen limiet aan het aantal argumenten dat een programma kan aannemen, maar de volgorde is kritisch. De JRE geeft de argumenten door in de volgorde waarin ze op de opdrachtregel verschijnen. Bekijk bijvoorbeeld dit codefragment van bovenaf:

openbare klasse CommandLineArgs2

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

System.out.println ("Er zijn geen opdrachtregelargumenten doorgegeven!");

Wanneer argumenten worden doorgegeven aan een Java-programma, is args [0] het eerste element van de array (waarde1 hierboven), args [1] is het tweede element (waarde2), enzovoort. De code args.length () definieert de lengte van de array.

Opdrachtregelargumenten doorgeven

In NetBeans kunnen we opdrachtregelargumenten doorgeven zonder dat we de toepassing moeten bouwen en uitvoeren vanuit een terminalvenster. De opdrachtregelargumenten opgeven:

Klik met de rechtermuisknop op de projectmap in de
```
projecten
```
venster.
Kies de
```
Eigendommen
```
optie om te openen
```
Project eigenschappen
```
venster.
In de
```
Categorieën
```
lijst aan de rechterkant, kies
```
Rennen
```
In de
```
argumenten
```
tekstvak dat wordt weergegeven, geeft u de opdrachtregelargumenten op die u aan de toepassing wilt doorgeven. Bijvoorbeeld als we binnenkomen
```
Appel Banaan Wortel
```
in de
```
argumenten
```
tekstvak en voer het
```
CommandLineArgs
```
programma hierboven vermeld, zullen we de output krijgen:

Argumenten van de opdrachtregel ontleden

Meestal wordt een opdrachtregelargument doorgegeven met wat informatie over wat te doen met de waarde die wordt doorgegeven. Het argument dat de toepassing informeert waarvoor het argument is, heeft meestal een koppelteken of twee voor de naam. Het NetBeans-voorbeeld voor de opstartparameter die het JDK-pad opgeeft, is bijvoorbeeld

Dit betekent dat u de opdrachtregelargumenten moet parseren om erachter te komen wat u met de waarden moet doen. Er zijn verschillende Java-opdrachtregelstructuren voor het ontleden van opdrachtregelargumenten. Of u kunt een eenvoudige opdrachtregelparser schrijven als de argumenten die u moet doorgeven niet zoveel zijn:

De bovenstaande code drukt de argumenten af of voegt ze samen toe als ze gehele getallen zijn. Dit opdrachtregelargument zou bijvoorbeeld de getallen toevoegen:

java CommandLineArgs -addnumbers 11 22 33 44

Wetenschap