Java Variable Parameter (Varargs)

In diesem Artikel werden Sie durch Beispiele lernen, wie Sie Variable Parameter (Varargs) in Java verwenden. Sie werden auch lernen, wann Sie Varargs verwenden und wann nicht.

Was ist Varargs in Java?

Angenommen, Sie erstellenJava Methoden. Aber Sie sind sich nicht sicher, wie viele Parameter Ihre Methode akzeptieren wird. Um dieses Problem zu lösen, verwendet Java 1.5Varargs wurden eingeführt.

Varargs ist die Abkürzung für Variable Argumente. In Java können Methoden eine beliebige Anzahl von Werten akzeptieren. Ein Parameter, der eine variable Anzahl von Werten akzeptieren kann, wird als varargs bezeichnet.

Die Syntax für die Implementierung von varargs ist wie folgt:

accessModifier methodName(datatype… arg) {
　　　　//　Methode Hauptteil
}

Um varargs zu definieren, werden in den Methodenparametern drei Punkte (...) verwendet.

Methoden, die eine variable Anzahl von Argumenten akzeptieren, werden als Variadic Methoden oder kurz varargs Methoden bezeichnet.

Zunächst lassen Sie uns ein Beispiel ohne varargs betrachten:

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));
　　　　}
}

Wenn Sie das Programm ausführen, wird die Ausgabe sein:

3
6

Wie Sie sehen können, muss die Methode sumNumber() überschrieben werden, um sie für3Argumente hinzufügen möchte.

wenn der Benutzer5eine Zahl oder10oder10Was soll ich tun, wenn ich 0 habe?

Mit varargs kann dieses Problem auf eine einfache Weise gelöst werden. Lassen Sie uns einen Code-Beispiel betrachten:

Beispiel: Demonstration der Arbeit mit variablen Argumenten

class VarargExample {
　　　　public int sumNumber(int ... args){
　　　　　　　　System.out.println("Parameter 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);
　　　　}
}

运行该程序时，输出为：

Parameterlänge:　2
sum2　=　6
Parameterlänge:　3
sum3　=　9
Parameterlänge:　4
sum4　=　16

Hier gibt die Methode sumNumber() die Summe der an sie übergebenen int-Parameter zurück (unabhängig von der Anzahl der übergebenen Parameter).

Wie Sie sehen können, sind Varargs in einigen Fällen sehr nützlich. Aber wenn Sie sicher sind, dass die Anzahl der an die Methode übergebenen Parameter festgelegt ist, verwenden Sie bitte die Methodenüberladung. Zum Beispiel, wenn Sie sicher sind, dass die Methode sumNumber() nur zur Berechnung2oder3Gesamtsumme der Parameter, verwenden Sie wie im ersten Beispiel die Überladung.

Lassen Sie uns noch ein weiteres Beispiel nennen. Die format() Methode, die in der Java-Bibliothek definiert ist, akzeptiert Varargs. In der JDK ist die format() Methode so definiert:

public static String format(Locale l, String format, Object... args) {
　　　　//　Körper
}

Beispiel: format() Methode

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount =　6;
　　　　　　　　String type = "Tutorial-Website";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Website Name: %s, Mitarbeiteranzahl: %d Typ: %s"
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　}
}

运行该程序时，输出为：

Website Name: oldtoolbag.com, Mitarbeiteranzahl:　6　Typ: Tutorial-Website

Wie arbeiten Variable Argumente im Hintergrund?

Lassen Sie uns das folgende Pseudocode betrachten:

public int sumNumber(int ... nums) {
　　　　//　Methode Hauptteil
}

...-Syntax teilt dem Java-Compiler mit, dass零个或多个参数 zur Aufrufung dieser Methode verwendet werden können. Somit wird die Variable nums implizit als int [] deklariertArrayDaher verwenden Sie im Methodeninneren die Array-Syntax, um auf die Variable nums zuzugreifen.

Wenn keine Parameter übergeben werden, beträgt die Länge von nums 0.

Varargs-Methode überladen

Wie bei typischen Methoden können Sie Varargs-Methode überladen.

Beispiel: Varargs-Methode überladen

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");
　　　　}
}

运行该程序时，输出为：

sum =　6
negate = false
args.length =　2

在上面的程序中，test()方法通过更改其接受的参数数量而重载。

使用 Varargs时应记住的事情

这是使用Java Varargs时应记住的几件事：

1在定义方法签名时，请务必保留最后可变参数。

可变参数必须是传递给方法的最后一个参数。考虑一下，您调用了如下doSomething()方法：

doSomething(1,　2,　3,　4);

并且，您的doSomething()方法定义为：

//错误的方法声明
public void doSomething(int ... nums, int p){
　　　　//　Methodeninhalt
}

在这种情况下，编译器无法确定传递给nums的参数数量。

但是，如果将方法定义为：

public void doSomething(int p, int ... nums) {
　　　　//　Methodeninhalt
}

Java编译器将第一个参数分配给 p，其余int参数分配给 nums。

2一种方法只能有一个可变参数。

例如，此方法声明不正确：

int doSomething(int p, float ... floatNums, double ... doubleNums) {
　　　　//　code
}

Mehrdeutigkeit bei der Varargs-Methodenüberladung

Lassen Sie uns solch eine überladene test() Methode betrachten:

class Demo {　
　　
　　　　static void test(int ... vargs) {
　　　　　　　　//　Methodeninhalt
　　　　}
　　　　
　　　　static void test(int n, int ... vargs) {
　　　　　　　　//　Methodeninhalt
　　　　}
}

Im obigen Programm wird der Compiler auch verwirrt, selbst wenn Sie versuchen, die test() Methode aufzurufen, selbst wenn die test() Methode überladen ist und unterschiedliche Anzahl an Parametern akzeptiert.

Der Compiler weiß nicht, welche Methode aufgerufen wird. Der Compiler könnte denken, dass Sie test(int ... vargs) mit einem varargs-Parameter aufrufen. Ebenso könnte der Compiler denken, dass Sie test(int n, int ... vargs) mit den an den ersten Parameter übergebenen Parametern aufrufen und der zweite Parameter leer ist.

Da es zwei Möglichkeiten gibt, kann es zu einer Mehrdeutigkeit kommen. Daher müssen Sie manchmal zwei verschiedene Methodennamen verwenden, anstatt varargs-Methode zu überladen.