¿Qué es SuppressWarnings ("unchecked") en Java?

Es una anotación para suprimir las advertencias de compilación sobre operaciones genéricas no verificadas (no excepciones), como los casts. Esencialmente implica que el programador no desea ser notificado acerca de estos que él ya es consciente de la compilación de un pedacito particular de código.

Puede leer más sobre esta anotación específica aquí:

SuppressWarnings

Además, Oracle proporciona documentación tutorial sobre el uso de anotaciones aquí:

Anotaciones

Como dicen,

"La advertencia 'sin marcar' puede ocurrir cuando se interactúa con código heredado escrito antes de la llegada de los genéricos (discutido en la lección titulada Genéricos)."

También podría significar que la versión actual del sistema de tipo Java no es lo suficientemente buena para su caso. Hubo varias proposiciones JSR / hacks para arreglar esto: Type tokens, Super Type Tokens, Class.elenco().

Si realmente necesitas esta supresión, acércala lo más posible (por ejemplo, no la pongas en la clase misma o en un método largo). Un ejemplo:

public List<String> getALegacyListReversed() {
   @SuppressWarnings("unchecked") List<String> list =
       (List<String>)legacyLibrary.getStringList();

   Collections.reverse(list);
   return list;
}

La anotación SuppressWarning se usa para suprimir las advertencias del compilador para el elemento anotado. Específicamente, la categoría unchecked permite la supresión de las advertencias del compilador generadas como resultado de casts de tipo sin marcar.

Simplemente: Es una advertencia mediante la cual el compilador indica que no puede garantizar la seguridad de tipos.

Método de servicio JPA por ejemplo:

@SuppressWarnings("unchecked")
public List<User> findAllUsers(){
    Query query = entitymanager.createQuery("SELECT u FROM User u");
    return (List<User>)query.getResultList();
}

Si no anotara el @SuppressWarnings("unchecked") aquí, tendría un problema con line, donde quiero devolver mi lista de resultados.

En atajo type-safety significa: Un programa se considera type-safe si compila sin errores y advertencias y no genera ningún clascastexception s inesperado en tiempo de ejecución.

Construyo el http://www.angelikalanger.com/GenericsFAQ/FAQSections/Fundamentals.html

Puede suprimir las advertencias del compilador y decirle a los genéricos que el código que ha escrito es legal de acuerdo con él.

Ejemplo:

@SuppressWarnings("unchecked")
public List<ReservationMealPlan> retreiveMealPlan() {
     List<ReservationMealPlan> list=new ArrayList<ReservationMealPlan>();
    TestMenuService testMenuService=new TestMenuService(em, this.selectedInstance);
    list = testMenuService.getMeal(reservationMealPlan);
    return list;
 }

Un truco es crear una interfaz que extienda una interfaz base genérica...

public interface LoadFutures extends Map<UUID, Future<LoadResult>> {}

Entonces puedes comprobarlo con instanceof antes del lanzamiento...

Object obj = context.getAttribute(FUTURES);
if (!(obj instanceof LoadFutures)) {
    String format = "Servlet context attribute \"%s\" is not of type "
            + "LoadFutures. Its type is %s.";
    String msg = String.format(format, FUTURES, obj.getClass());
    throw new RuntimeException(msg);
}
return (LoadFutures) obj;

En Java, los genéricos se implementan mediante el tipo erasure. Por ejemplo, el siguiente código.

List<String> hello = List.of("a", "b");
String example = hello.get(0);

Se compila de la siguiente manera.

List hello = List.of("a", "b");
String example = (String) hello.get(0);

Y List.of se define como.

static <E> List<E> of(E e1, E e2);

Que después del tipo se convierte en borrado.

static List of(Object e1, Object e2);

El compilador no tiene idea de cuáles son los tipos genéricos en tiempo de ejecución, así que si escribes algo como esto.

Object list = List.of("a", "b");
List<Integer> actualList = (List<Integer>) list;

Java Virtual Machine no tiene idea de qué tipos genéricos son mientras se ejecuta un programa, por lo que este compila y se ejecuta, como para Java Virtual Machine, este es un tipo cast to List (esto es lo único que puede verificar, por lo que solo verifica eso).

Pero ahora añade esta línea.

Integer hello = actualList.get(0);

Y JVM lanzará un inesperado ClassCastException, ya que el compilador Java insertó un cast implícito.

java.lang.ClassCastException: java.base/java.lang.String cannot be cast to java.base/java.lang.Integer

Una advertencia unchecked le dice a un programador que un cast puede causar que un programa lance una excepción en otro lugar. Suprimiendo la advertencia con @SuppressWarnings("unchecked") le dice al compilador que el programador cree que el código es seguro y no causará excepciones inesperadas.

¿Por qué querrías hacer eso? El sistema de tipos Java no es lo suficientemente bueno para representar todos los patrones de uso de tipos posibles. A veces puede saber que un cast es seguro, pero Java no proporciona una manera de decirlo - para ocultar advertencias como esta, se puede usar @SupressWarnings("unchecked"), para que un programador pueda centrarse en advertencias reales. Por ejemplo, Optional.empty() devuelve un singleton para evitar la asignación de opciones vacías que no almacenan un valor.

private static final Optional<?> EMPTY = new Optional<>();
public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

Este molde es seguro, ya que el el valor almacenado en una opción vacía no se puede recuperar, por lo que no hay riesgo de excepciones inesperadas de transmisión de clases.

Por lo que sé, por ahora tiene que ver con la supresión de advertencias sobre genéricos; los genéricos son una nueva construcción de programación no soportada en versiones JDK anteriores a JDK 5, por lo que cualquier mezcla de las viejas construcciones con las nuevas podría plantear algunos resultados inesperados.

El compilador advierte al programador al respecto, pero si el programador ya lo sabe, puede desactivar esas temidas advertencias usando SuppressWarnings.