SafeVarargs

AI-generated Key Takeaways

• @SafeVarargs asserts that a method or constructor handles its varargs parameter safely, suppressing related unchecked warnings.

• It can only be applied to static or final variable arity methods and constructors.

• While it suppresses warnings, @SafeVarargs doesn't guarantee type safety at runtime; potentially unsafe operations on varargs can still lead to exceptions like ClassCastException.

• Compilers may issue warnings if @SafeVarargs is used on methods with reifiable element types (like Object or String) or if the method contains potentially unsafe operations on the varargs array.

public abstract @interface SafeVarargs implements Annotation

A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter. Applying this annotation to a method or constructor suppresses unchecked warnings about a non-reifiable variable arity (vararg) type and suppresses unchecked warnings about parameterized array creation at call sites.

In addition to the usage restrictions imposed by its @Target meta-annotation, compilers are required to implement additional usage restrictions on this annotation type; it is a compile-time error if a method or constructor declaration is annotated with a @SafeVarargs annotation, and either:

• the declaration is a fixed arity method or constructor
• the declaration is a variable arity method that is neither static nor final.

Compilers are encouraged to issue warnings when this annotation type is applied to a method or constructor declaration where:

• The variable arity parameter has a reifiable element type, which includes primitive types, Object, and String. (The unchecked warnings this annotation type suppresses already do not occur for a reifiable element type.)
• The body of the method or constructor declaration performs potentially unsafe operations, such as an assignment to an element of the variable arity parameter's array that generates an unchecked warning. Some unsafe operations do not trigger an unchecked warning. For example, the aliasing in

   @SafeVarargs // Not actually safe!
   static void m(List<String>... stringLists) {
     Object[] array = stringLists;
     List<Integer> tmpList = Arrays.asList(42);
     array[0] = tmpList; // Semantically invalid, but compiles without warnings
     String s = stringLists[0].get(0); // Oh no, ClassCastException at runtime!
   }
   

  leads to a ClassCastException at runtime.

  Future versions of the platform may mandate compiler errors for such unsafe operations.

Inherited Method Summary

From interface java.lang.annotation.Annotation

abstract Class<? extends Annotation>	annotationType() Returns the annotation type of this annotation.
abstract boolean	equals(Object obj) Returns true if the specified object represents an annotation that is logically equivalent to this one.
abstract int	hashCode() Returns the hash code of this annotation, as defined below: The hash code of an annotation is the sum of the hash codes of its members (including those with default values), as defined below: The hash code of an annotation member is (127 times the hash code of the member-name as computed by String.hashCode()) XOR the hash code of the member-value, as defined below: The hash code of a member-value depends on its type: The hash code of a primitive value v is equal to WrapperType.valueOf(v).hashCode(), where WrapperType is the wrapper type corresponding to the primitive type of v (Byte, Character, Double, Float, Integer, Long, Short, or Boolean).
abstract String	toString() Returns a string representation of this annotation.