Opdrachtregelargumenten gebruiken in Java

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

Bijvoorbeeld, NetBeans heeft een aantal opstartparameters die kunnen worden doorgegeven aan de applicatie 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-applicatie).

De belangrijkste methode

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

De opdrachtregelargumenten zijn te vinden in de

gebeld

Laten we bijvoorbeeld eens kijken naar een applicatie met de naam

instagram viewer

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

openbare klasse CommandLineArgs {

 openbare statische leegte main (String [] args) {
// controleer of de String-array leeg is
if (args.length == 0)
{
System.out.println ("Er zijn geen opdrachtregelargumenten doorgegeven!");
}

 // Voor elke String in de String-array
// print de String.
voor (String argument: args)
{
System.out.println (argument);
}
}
}

Syntaxis van opdrachtregelargumenten

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

java ProgramName waarde1 waarde2

Hierboven roept "java" de JRE op, die wordt 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 van cruciaal belang. De JRE geeft de argumenten door in de volgorde waarin ze op de opdrachtregel verschijnen. Bekijk bijvoorbeeld dit codefragment van boven:

openbare klasse CommandLineArgs2 {

 openbare statische leegte 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 de applicatie te hoeven bouwen en vanuit een terminalvenster uit te voeren. Om de opdrachtregelargumenten op te geven:

Klik met de rechtermuisknop op de projectmap in de
```
Projecten
```
venster.
Kies de
```
Eigendommen
```
optie om te openen
```
Projecteigenschappen
```
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
```
Apple Banana Carrot
```
in de
```
Argumenten
```
tekstvak en voer de
```
CommandLineArgs
```
programma hierboven vermeld, krijgen we de uitvoer:

De opdrachtregelargumenten ontleden

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

Dit betekent dat u de opdrachtregelargumenten moet ontleden om erachter te komen wat u met de waarden moet doen. Er zijn verschillende Java-opdrachtregelframes voor het ontleden van opdrachtregelargumenten. Of u zou een eenvoudige parser voor de opdrachtregel kunnen schrijven als de argumenten die u moet doorgeven niet zo veel zijn:

De code hierboven drukt de argumenten af of voegt ze bij elkaar als ze gehele getallen zijn. Dit opdrachtregelargument zou bijvoorbeeld de cijfers toevoegen:

java CommandLineArgs -addnummers 11 22 33 44