Java SafeVarargs-Annotation, existiert ein Standard oder eine Best Practice?

1) Es gibt viele Beispiele im Internet und auf StackOverflow über das jeweilige Problem mit generics und varargs. Im Grunde ist es, wenn Sie eine variable Anzahl von Argumenten von einem Typ-parameter Typ:

void foo(T... args);

In Java varargs sind syntaktischer Zucker, der erfährt eine einfache "neu-schreiben" zur compile-Zeit: ein varargs-parameter von Typ X... wird umgewandelt in einen parameter vom Typ X[]; und jedes mal, wenn ein Anruf aus dieser varargs-Methode, der compiler sammelt alle "variable Argumente", das geht in die varargs-parameter und erstellt ein array genau wie new X[] { ...(arguments go here)... }.

Dies funktioniert gut, wenn die varargs-Typ ist Beton wie String.... Wenn es eine variable vom Typ wie T... es auch funktioniert, wenn T ist bekannt, dass ein konkreter Typ für diesen Anruf. wenn z.B. die oben genannte Methode benutzt, waren Teil einer Klasse Foo<T>, und Sie haben eine Foo<String> Verweis aufrufen foo auf, es wäre okay, weil wir wissen T ist String an diesem Punkt im code.

Aber es funktioniert nicht, wenn der "Wert" von T ist ein anderer Typ-parameter. In Java ist es unmöglich, ein array zu erstellen von einer Typ-parameter-Komponente Typ (new T[] { ... }). Also Java verwendet stattdessen new Object[] { ... } (hier Object ist die Obere Grenze T; wenn es eine Obere Schranke waren etwas anderes wäre es, dass statt Object), und gibt Ihnen dann eine compiler-Warnung.

Also, was ist falsch mit dem erstellen von new Object[] statt new T[] oder was auch immer? Gut, arrays in Java wissen, dass Ihre Komponententyp zur Laufzeit. So werden die übergebenen array-Objekt wird die falsche Komponente Typ zur Laufzeit.

Wohl die häufigste Verwendung von varargs, einfach zu iterieren über die Elemente, das ist kein problem (Sie kümmern sich nicht um die Laufzeit-Typ des Arrays), so ist dies sicher:

@SafeVarargs
final void foo(T... args) {
    for (T x : args) {
        //do stuff with x
    }
}

Jedoch für alles, was hängt von der runtime-Komponente Typ des übergebenen array, wird es nicht sicher sein. Hier ist ein einfaches Beispiel für etwas, das unsichere und stürzt ab:

class UnSafeVarargs
{
  static <T> T[] asArray(T... args) {
    return args;
  }

  static <T> T[] arrayOfTwo(T a, T b) {
    return asArray(a, b);
  }

  public static void main(String[] args) {
    String[] bar = arrayOfTwo("hi", "mom");
  }
}

Das problem hier ist, dass wir abhängig von der Art der args zu T[] um es zurückzugeben, wie T[]. Aber eigentlich ist der Typ des Arguments zur Laufzeit ist nicht eine Instanz von T[].

3) Wenn Ihr Methode ein argument vom Typ T... (wobei T einen beliebigen Typ-parameter), dann:

• Sicher: Wenn Ihre Methode hängt nur von der Tatsache, dass die Elemente des Arrays sind Instanzen von T
• Unsicher: Wenn hängt es von der Tatsache, dass das array eine Instanz der T[]

Dinge, die abhängig von der Laufzeit-Typ des Arrays umfassen: die Rückgabe wird als Typ T[] auf, übergeben Sie als argument an einen parameter vom Typ T[] daran, den array-Typ mit .getClass(), übergabe an Methoden, die abhängig von der Laufzeit-Typ des Arrays, wie List.toArray() und Arrays.copyOf() usw.

2) Die Unterscheidung, die ich oben erwähnt ist zu kompliziert, zu leicht zu unterscheiden automatisch.

InformationsquelleAutor der Antwort newacct