In dit artikel leer je aan de hand van voorbeelden over varargs in Java. U leert ook wanneer u varargs moet gebruiken en wanneer u ze niet moet gebruiken.
Wat is varargs in Java?
Stel dat u een Java-methode maakt. U weet echter niet zeker hoeveel argumenten uw methode zal accepteren. Om dit probleem op te lossen, introduceerde Java 1.5 varargs.
Varargs is een korte naam voor variabele argumenten. In Java kan een argument van een methode een willekeurig aantal waarden accepteren. Dit argument dat een variabel aantal waarden kan accepteren, wordt varargs genoemd.
De syntaxis voor het implementeren van varargs is als volgt:
accessModifier methodName (datatype… arg) (// body van de methode)
Om vararg te definiëren, wordt … (drie punten) gebruikt in de formele parameter van een methode.
Een methode die een variabel aantal argumenten accepteert, wordt een variabele-ariteitsmethode genoemd, of gewoon een varargs-methode.
Laten we eerst het voorbeeld bekijken zonder varargs te gebruiken:
class NoVararg ( public int sumNumber(int a, int b)( return a+b; ) public int sumNumber(int a, int b, int c)( return a+b+c; ) public static void main( String() args ) ( NoVararg obj = new NoVararg(); System.out.println(obj.sumNumber(1, 2)); System.out.println(obj.sumNumber(1, 2, 3)); ) )
Wanneer u dit programma uitvoert, is de uitvoer:
3 6
Zoals je duidelijk kunt zien, moest je de sumNumber()methode overbelasten om het voor 3 argumenten te laten werken.
Wat als de gebruiker 5 nummers of 10 of 100 wil toevoegen?
Dit kan op een nette manier worden aangepakt met behulp van varargs. Laten we een codevoorbeeld bekijken:
Voorbeeld: werken met varargs
class VarargExample ( public int sumNumber(int… args)( System.out.println("argument length: " + args.length); int sum = 0; for(int x: args)( sum += x; ) return sum; ) public static void main( String() args ) ( VarargExample ex = new VarargExample(); int sum2 = ex.sumNumber(2, 4); System.out.println("sum2 = " + sum2); int sum3 = ex.sumNumber(1, 3, 5); System.out.println("sum3 = " + sum3); int sum4 = ex.sumNumber(1, 3, 5, 7); System.out.println("sum4 = " + sum4); ) )
Wanneer u het programma uitvoert, is de uitvoer:
lengte van het argument: 2 som2 = 6 lengte van het argument: 3 som3 = 9 lengte van het argument: 4 som4 = 16
Hier sumNumber()retourneert de methode de som van de intparameters die eraan zijn doorgegeven (maakt niet uit hoeveel argumenten er zijn doorgegeven).
Zoals u kunt zien, kunnen varargs in sommige situaties erg handig zijn. Als u echter zeker bent van het aantal argumenten dat aan een methode wordt doorgegeven, gebruikt u in plaats daarvan overbelasting van de methode. Als u er bijvoorbeeld zeker van bent dat die sumNumber()methode alleen wordt gebruikt om de som van 2 of 3 argumenten te berekenen, gebruikt u overbelasting zoals in het eerste voorbeeld.
Laten we een ander voorbeeld nemen. De methode format () die is gedefinieerd in de Java-bibliotheek, accepteert varargs. In JDK wordt de format()methode als volgt gedefinieerd:
openbare statische String-indeling (Locale l, String-indeling, Object … args) (// body)
Voorbeeld: format () methode
class Company ( public static void main(String() args) ( String siteName = "programiz.com"; int empCount = 6; String type = "tutorial website"; System.out.println( String.format( "Site Name : %s, Emp Count: %d Type: %s", siteName, empCount, type ) ); ) )
Wanneer u het programma uitvoert, is de uitvoer:
Sitenaam: programiz.com, aantal Emp: 6 Type: zelfstudiewebsite
Hoe werkt Varargs achter de schermen?
Laten we de volgende pseudo-code bekijken:
public int sumNumber (int … nums) (// methode body)
De … syntaxis vertelt de Java-compiler dat de methode kan worden aangeroepen met nul of meer argumenten. Als resultaat wordt de variabele nums impliciet gedeclareerd als een array van het type int( ). Dus binnen de methode wordt de variabele nums benaderd met behulp van de array-syntaxis.
Als er geen argumenten zijn, is de lengte van getallen 0.
Overbelasting van Varargs-methoden
Net als bij typische methoden, kunt u vararg-methoden overbelasten.
Aanbevolen literatuur: overbelasting van de Java-methode
Voorbeeld: Overbelasting van de Varargs-methode
class VarargOverload ( private void test(int… args)( int sum = 0; for (int i: args) ( sum += i; ) System.out.println("sum = " + sum); ) private void test(boolean p, String… args)( boolean negate = !p; System.out.println("negate = " + negate); System.out.println("args.length = "+ args.length); ) public static void main( String() args ) ( VarargOverload obj = new VarargOverload(); obj.test(1, 2, 3); obj.test(true, "hello", "world"); ) )
Wanneer u het programma uitvoert, is de uitvoer:
som = 6 ontkennen = false args.length = 2
In het bovenstaande programma wordt de test()methode overbelast door het aantal argumenten dat het accepteert te wijzigen.
Dingen om te onthouden tijdens het gebruik van Varargs
Hier zijn een paar dingen die u moet onthouden tijdens het werken met Java-vargars:
1. Houd bij het definiëren van de methodehandtekening altijd varargs aan.
Het variabele-argument moet het laatste argument zijn dat aan de methode is doorgegeven. Laten we eens kijken, je hebt de doSomething()methode als volgt aangeroepen :
doSomething (1, 2, 3, 4);
En uw doSomething()methode is gedefinieerd als:
// onjuiste methode declaratie public void doSomething (int … nums, int p) (// method body)
In dit geval kan de compiler het aantal argumenten dat aan nums is doorgegeven niet achterhalen.
Als u uw methode echter definieert als:
public void doSomething (int p, int … nums) (// method body)
De Java-compiler wijst het eerste argument toe aan p, en de overige intargumenten worden toegewezen aan nums.
2. Een methode kan maar één varargs-parameter hebben.
Deze methode-declaratie is bijvoorbeeld onjuist:
int doSomething (int p, float … floatNums, double … doubleNums) (// code)
Ambiguïteit in overbelasting van de Varargs-methode
Laten we uw overbelaste test()methode als volgt beschouwen:
class Demo (static void test (int… vargs) (// method body) static void test (int n, int… vargs) (// method body))
In het bovenstaande programma raakt de compiler in de war als u de test()methode probeert aan te roepen , ook al zijn de test()methoden overbelast en accepteert een ander aantal argumenten.
De compiler weet niet welke methode hij moet aanroepen. De compiler denkt misschien dat je probeert te bellen test(int… vargs)met één varargs-argument. Ook kan de compiler denken dat u probeert aan te roepen test(int n, int… vargs)met een argument dat is doorgegeven aan de eerste parameter met een lege tweede parameter.
Aangezien er twee mogelijkheden zijn, veroorzaakt dit ambiguïteit. Daarom moet u soms twee verschillende methodenamen gebruiken in plaats van de varargs-methode te overbelasten.
