Den Varargs-Mechanismus in Java verstehen

J2SE 1.5 bietet den „Varargs“-Mechanismus. Mit diesem Mechanismus können Sie formale Parameter definieren, die mit mehreren tatsächlichen Parametern übereinstimmen können. Somit kann auf einfachere Weise eine variable Anzahl von Aktualparametern übergeben werden. In diesem Artikel wird die Verwendung dieses Mechanismus sowie verschiedene Probleme vorgestellt, wenn dieser Mechanismus mit Arrays, Generika und Überladung interagiert.

Bis J2SE 1.4 war es unmöglich, eine Methode mit einer variablen Anzahl tatsächlicher Parameter in einem Java-Programm zu definieren, da Java erfordert, dass die Anzahl und der Typ tatsächlicher Parameter (Argumente) und formaler Parameter (Parameter) festgelegt werden ) muss nacheinander übereinstimmen und die Anzahl der formalen Parameter wird bei der Definition der Methode festgelegt. Obwohl der Überladungsmechanismus verwendet werden kann, um Versionen mit unterschiedlicher Anzahl formaler Parameter für dieselbe Methode bereitzustellen, kann damit immer noch nicht der Zweck erreicht werden, die tatsächlichen Parametermengen beliebig ändern zu können.

Die Semantik einiger Methoden erfordert jedoch, dass sie in der Lage sein müssen, eine variable Anzahl tatsächlicher Parameter zu akzeptieren – beispielsweise muss die berühmte Hauptmethode in der Lage sein, alle Befehlszeilenparameter als tatsächliche Parameter zu akzeptieren, und Die Befehlszeilenparameter Die Anzahl kann nicht im Voraus bestimmt werden.

Für dieses Problem wird traditionell der Ansatz verwendet, „ein Array zu verwenden, um die tatsächlich zu übergebenden Parameter zu verpacken“, um dieses Problem zu lösen.

Aktuelle Parameter mit Arrays umschließen

Die Methode „Aktuelle Parameter mit Arrays umschließen“ kann in drei Schritte unterteilt werden: Definieren Sie zunächst einen Array-Parameter für diese Methode. Generieren Sie dann beim Aufruf ein Array, das alle zu übergebenden tatsächlichen Parameter enthält. Übergeben Sie dieses Array schließlich als tatsächliche Parameter.

Dieser Ansatz kann effektiv den Zweck erreichen, „der Methode zu erlauben, eine variable Anzahl von Parametern zu akzeptieren“, aber die Form des Aufrufs ist nicht einfach genug.

J2SE 1.5 bietet den Varargs-Mechanismus, mit dem Sie formale Parameter direkt definieren können, die mit mehreren tatsächlichen Parametern übereinstimmen können. Somit kann auf einfachere Weise eine variable Anzahl von Aktualparametern übergeben werden.

Die Bedeutung von Varargs

Im Allgemeinen bedeutet „Varargs“ „variable Anzahl von Argumenten“. Manchmal wird es auch einfach als „variable Argumente“ bezeichnet, aber da dieser Begriff nicht erklärt, was variabel ist, ist die Bedeutung etwas vage.

Eine Methode zum Definieren einer variablen Anzahl tatsächlicher Parameter

Fügen Sie einfach drei aufeinanderfolgende „“ zwischen dem „Typ“ und dem „Parameternamen“ eines formalen Parameters hinzu. (das heißt „…“, die Auslassungspunkte im Satz auf Englisch), können Sie es mit einer unbestimmten Anzahl tatsächlicher Parameter abgleichen. Eine Methode mit solchen formalen Parametern ist eine Methode mit einer variablen Anzahl tatsächlicher Parameter.

Listing 1: Eine Methode mit variabler Anzahl tatsächlicher Parameter

private static int sumUp(int... values) {    
}

Beachten Sie, dass nur der letzte formale Parameter definiert werden kann als „Übereinstimmung mit einer unbestimmten Anzahl tatsächlicher Argumente“. Daher kann es in einer Methode nur einen solchen Parameter geben. Wenn diese Methode außerdem andere formale Parameter hat, setzen Sie diese an die erste Stelle.

Der Compiler wandelt diesen letzten formalen Parameter heimlich in einen Array-Parameter um und setzt eine Markierung in die kompilierte Klassendatei, um anzuzeigen, dass es sich um eine Methode mit einer variablen Anzahl tatsächlicher Parameter handelt.

Listing 2: Geheimform einer Methode mit variabler Anzahl tatsächlicher Parameter

private static int sumUp(int[] values) {    
}

Weil es eine solche Transformation gibt , sodass Sie für diese Klasse keine Methode mehr mit derselben Signatur wie die konvertierte Methode definieren können.

Listing 3: Kombinationen, die Kompilierungsfehler verursachen

private static int sumUp(int... values) {   
}   

private static int sumUp(int[] values) {   
}

Blank-Survival-Problem

nach In J2SE 1.5-Syntax, das Leerzeichen vor „…“ ist optional. Auf diese Weise gibt es zwei Schreibweisen: das Hinzufügen von Leerzeichen vor „…“ (gebildet als „Object... args“) und das Nicht-Hinzufügen von Leerzeichen vor „…“ (gebildet als „ Objekt... args"). Da die derzeit mit J2SE 1.5 kompatiblen Java-Codekonventionen nicht offiziell veröffentlicht wurden, ist es unmöglich zu wissen, welche Schreibmethode orthodoxer ist. Wenn man jedoch bedenkt, dass Array-Parameter auch auf zwei Arten geschrieben werden können: „Object [] args“ und „Object [] args“, und die orthodoxe Schreibweise darin besteht, vor „[]“ keine Leerzeichen hinzuzufügen, scheint dies zu verwenden „Objekt... args“ ohne Leerzeichen „Die Schreibweise ist insgesamt koordinierter.“

Eine Methode mit einer variablen Anzahl tatsächlicher Parameter aufrufen

Solange Sie die zu übergebenden tatsächlichen Parameter einzeln an die entsprechenden Positionen schreiben, können Sie aufrufen eine Methode mit einer variablen Anzahl tatsächlicher Parameter, veränderbare Methoden. Es sind keine weiteren Schritte erforderlich.

Listing 4: Mehrere tatsächliche Parameter können übergeben werden

sumUp(1, 3, 5, 7);

Hinter den Kulissen führt der Compiler diesen Aufruf aus Der Prozess wird in die Form „Umschließen tatsächlicher Parameter mit einem Array“ umgewandelt:

Listing 5: Heimlich erscheinende Array-Erstellung

sumUp(new int[]{1, 2, 3, 4});

Außerdem umfasst die hier erwähnte „unsichere Zahl“ auch Null, sodass ein solcher Aufruf auch sinnvoll ist:

Listing 6: Sie können auch Null-Aktualparameter übergeben

sumUp(); 

这种调用方法被编译器秘密转化之后的效果，则等同于这样：

Listing 7: Null-Argument entsprechend leerem Array

sumUp(new int[]{});

Beachten Sie dies Was übergeben wird, ist ein leeres Array, nicht null. Auf diese Weise kann es in einheitlicher Form gehandhabt werden, ohne dass ermittelt werden muss, zu welcher Situation es gehört.

4. 处理个数可变的实参

处理个数可变的实参的办法，和处理数组实参的办法基本相同。所有的实参，都被保存到一个和形参同名的数组里。根据实际的需要，把这个数组里的元素读出之后，要蒸要煮，就可以随意了。

清单8：处理收到的实参们

private static int sumUp(int... values) {   
    int sum = 0;   
    for (int i = 0; i < values.length; i++) {   
        sum += values[i];   
    }   
    return sum;   
}

5. 转发个数可变的实参

有时候，在接受了一组个数可变的实参之后，还要把它们传递给另一个实参个数可变的方法。因为编码时无法知道接受来的这一组实参的数目，所以“把它们 逐一写到该出现的位置上去”的做法并不可行。不过，这并不意味着这是个不可完成的任务，因为还有另外一种办法，可以用来调用实参个数可变的方法。

在J2SE 1.5的编译器的眼中，实参个数可变的方法是最后带了一个数组形参的方法的特例。因此，事先把整组要传递的实参放到一个数组里，然后把这个数组作为最后一个实参，传递给一个实参个数可变的方法，不会造成任何错误。借助这一特性，就可以顺利的完成转发了。

清单9：转发收到的实参们

public class PrintfSample {   

    public static void main(String[] args) {   
        // 打印出“Pi:3.141593 E:2.718282”   
        printOut("Pi:%f E:%f/n", Math.PI, Math.E);   
    }   

    private static void printOut(String format, Object... args) {   
        // J2SE 1.5里PrintStream新增的printf(String format, Object... args)方法   
        System.out.printf(format, args);   
    }   
}

Java里的“printf”和“sprintf”

C语言里的printf（按一定的格式输出字符串）和sprintf（按一定的格式组合字符串）是十分经典的使用Varargs机制的例子。在 J2SE 1.5中，也分别在java.io.PrintStream类和java.lang.String类中提供了类似的功能。

按一定的格式输出字符串的功能，可以通过调用PrintStream对象的printf(String format, Object… args)方法来实现。

按一定的格式组合字符串的工作，则可以通过调用String类的String format(String format, Object… args)静态方法来进行。

6. 是数组？不是数组？

尽管在背地里，编译器会把能匹配不确定个实参的形参，转化为数组形参；而且也可以用数组包了实参，再传递给实参个数可变的方法；但是，这并不表示“能匹配不确定个实参的形参”和“数组形参”完全没有差异。

一个明显的差异是，如果按照调用实参个数可变的方法的形式，来调用一个最后一个形参是数组形参的方法，只会导致一个“cannot be applied to”的编译错误。

清单10：一个“cannot be applied to”的编译错误

private static void testOverloading(int[] i) {   
    System.out.println("A");   
}   

public static void main(String[] args) {   
    testOverloading(1, 2, 3);// 编译出错   
}

由于这一原因，不能在调用只支持用数组包裹实参的方法的时候（例如在不是专门为J2SE 1.5设计第三方类库中遗留的那些），直接采用这种简明的调用方式。

如果不能修改原来的类，为要调用的方法增加参数个数可变的版本，而又想采用这种简明的调用方式，那么可以借助“引入外加函数（Introduce Foreign Method）”和“引入本地扩展（Intoduce Local Extension）”的重构手法来近似的达到目的。

7. 当个数可变的实参遇到泛型

J2SE 1.5中新增了“泛型”的机制，可以在一定条件下把一个类型参数化。例如，可以在编写一个类的时候，把一个方法的形参的类型用一个标识符（如T）来代表， 至于这个标识符到底表示什么类型，则在生成这个类的实例的时候再行指定。这一机制可以用来提供更充分的代码重用和更严格的编译时类型检查。

不过泛型机制却不能和个数可变的形参配合使用。如果把一个能和不确定个实参相匹配的形参的类型，用一个标识符来代表，那么编译器会给出一个“generic array creation”的错误。

清单11：当Varargs遇上泛型

private static <T> void testVarargs(T... args) {   
    // 编译出错   
}

造成这个现象的原因在于J2SE 1.5中的泛型机制的一个内在约束——不能拿用标识符来代表的类型来创建这一类型的实例。在出现支持没有了这个约束的Java版本之前，对于这个问题，基本没有太好的解决办法。

不过，传统的“用数组包裹”的做法，并不受这个约束的限制。

清单12：可以编译的变通做法

private static <T> void testVarargs(T[] args) {   
    for (int i = 0; i < args.length; i++) {   
        System.out.println(args[i]);   
    }   
}

8. 重载中的选择问题

Java支持“重载”的机制，允许在同一个类拥有许多只有形参列表不同的方法。然后，由编译器根据调用时的实参来选择到底要执行哪一个方法。

传统上的选择，基本是依照“特殊者优先”的原则来进行。一个方法的特殊程度，取决于为了让它顺利运行而需要满足的条件的数目，需要条件越多的越特殊。

在引入Varargs机制之后，这一原则仍然适用，只是要考虑的问题丰富了一些——传统上，一个重载方法的各个版本之中，只有形参数量与实参数量正 好一致的那些有被进一步考虑的资格。但是Varargs机制引入之后，完全可以出现两个版本都能匹配，在其它方面也别无二致，只是一个实参个数固定，而一 个实参个数可变的情况。

遇到这种情况时，所用的判定规则是“实参个数固定的版本优先于实参个数可变的版本”。

清单13：实参个数固定的版本优先

public class OverloadingSampleA {   

    public static void main(String[] args) {   
        testOverloading(1);// 打印出A   
        testOverloading(1, 2);// 打印出B   
        testOverloading(1, 2, 3);// 打印出C   
    }   

    private static void testOverloading(int i) {   
        System.out.println("A");   
    }   

    private static void testOverloading(int i, int j) {   
        System.out.println("B");   
    }   

    private static void testOverloading(int i, int... more) {   
        System.out.println("C");   
    }   
}

如果在编译器看来，同时有多个方法具有相同的优先权，它就会陷入无法就到底调用哪个方法作出一个选择的状态。在这样的时候，它就会产生一个 “reference to 被调用的方法名 is ambiguous”的编译错误，并耐心的等候作了一些修改，足以免除它的迷惑的新源代码的到来。

在引入了Varargs机制之后，这种可能导致迷惑的情况，又增加了一些。例如现在可能会有两个版本都能匹配，在其它方面也如出一辙，而且都是实参个数可变的冲突发生。

清单14：左右都不是，为难了编译器

public class OverloadingSampleB {   

    public static void main(String[] args) {   
        testOverloading(1, 2, 3);// 编译出错   
    }   

    private static void testOverloading(Object... args) {   
    }   

    private static void testOverloading(Object o, Object... args) {   
    }   
}

另外，因为J2SE 1.5中有“Autoboxing/Auto-Unboxing”机制的存在，所以还可能发生两个版本都能匹配，而且都是实参个数可变，其它方面也一模一样，只是一个能接受的实参是基本类型，而另一个能接受的实参是包裹类的冲突发生。

清单15：Autoboxing/Auto-Unboxing带来的新问题

public class OverloadingSampleC {   

    public static void main(String[] args) { /* 编译出错 */  
        testOverloading(1, 2); /* 还是编译出错 */  
        testOverloading(new Integer(1), new Integer(2));   
    }   

    private static void testOverloading(int... args) {   
    }   

    private static void testOverloading(Integer... args) {   
    }   
}

9. 归纳总结

和“用数组包裹”的做法相比，真正的实参个数可变的方法，在调用时传递参数的操作更为简单，含义也更为清楚。不过，这一机制也有它自身的局限，并不是一个完美无缺的解决方案。

 以上就是Java 中 Varargs 机制的理解 的内容，更多相关内容请关注PHP中文网（www.php.cn）！