Qu'est-ce que SuppressWarnings ("unchecked") en Java?

C'est une annotation pour supprimer les avertissements de compilation concernant les opérations génériques non cochées (pas les exceptions), telles que les conversions. Cela implique essentiellement que le programmeur n'a pas souhaité être informé de ceux-ci dont il est déjà au courant lors de la compilation d'un bit de code particulier.

Vous pouvez en savoir plus sur cette annotation spécifique ici:

Supprimer les Avertissements

En outre, Oracle fournit une documentation tutorielle sur l'utilisation des annotations ici:

Annotations

Comme ils le disent,

"L'avertissement' non coché ' peut se produire lors de l'interface avec du code hérité écrit avant l'avènement des génériques (discuté dans la leçon intitulée Generics)."

Cela pourrait également signifier que la version actuelle du système de type Java n'est pas assez bonne pour votre cas. Il y avait plusieurs propositions JSR / hacks pour résoudre ce problème: type tokens, Super Type Tokens , Class.jeter().

Si vous avez vraiment besoin de cette suppression, réduisez-la autant que possible (par exemple, ne la mettez pas sur la classe elle-même ou sur une méthode longue). Un exemple:

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

   Collections.reverse(list);
   return list;
}

Le SuppressWarning annotation est utilisée pour supprimer les avertissements du compilateur pour l'élément. Plus précisément, la catégorie unchecked permet la suppression des avertissements du compilateur générés à la suite de conversions de type non cochées.

Simplement: c'est un avertissement par lequel le compilateur indique qu'il ne peut pas assurer la sécurité du type.

Méthode de service JPA par exemple:

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

Si je n'ai pas anoté le @ SuppressWarnings ("décoché") ici, il y aurait un problème avec line, où je veux retourner ma liste de résultats.

Dans le raccourci type-safety signifie: un programme est considéré comme sûr s'il compile sans erreurs ni avertissements et ne déclenche aucune ClassCastException inattendue lors de l'exécution.

Je construis sur http://www.angelikalanger.com/GenericsFAQ/FAQSections/Fundamentals.html

Vous pouvez supprimer les avertissements du compilateur et dire aux génériques que le code que vous avez écrit est légal selon lui.

Exemple:

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

Une astuce consiste à créer une interface qui étend une interface de base générique...

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

Ensuite, vous pouvez le vérifier avec instanceof avant la distribution...

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, les génériques sont implémentés au moyen de l'effacement de type. Par exemple, le code suivant.

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

Est compilé comme suit.

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

Et List.of est défini comme.

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

Qui après effacement de type devient.

static List of(Object e1, Object e2);

Le compilateur n'a aucune idée de ce que sont les types génériques à l'exécution, donc si vous écrivez quelque chose comme ceci.

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

Java Virtual Machine n'a aucune idée de ce que sont les types génériques lors de l'exécution d'un programme, donc cela compile et s'exécute, comme pour la machine virtuelle Java, il s'agit d'un cast de type List (c'est la seule chose qu'il peut vérifier, donc il vérifie seulement cela).

Mais maintenant Ajoutez cette ligne.

Integer hello = actualList.get(0);

Et JVM lancera un ClassCastException inattendu, car le compilateur Java a inséré un cast implicite.

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

Un avertissement unchecked indique à un programmeur qu'une distribution peut amener un programme à lancer une exception ailleurs. La suppression de l'avertissement avec @SuppressWarnings("unchecked") indique au compilateur que le programmeur croit que le code est sûr et ne fera pas exception inattendue.

Pourquoi voudriez-vous faire cela? Le système de type Java n'est pas assez bon pour représenter tous les modèles d'utilisation de type possibles. Parfois, vous savez peut - être qu'un cast est sûr, mais Java ne fournit pas un moyen de le dire-pour cacher des avertissements comme celui-ci, @SupressWarnings("unchecked") peut être utilisé, de sorte qu'un programmeur peut se concentrer sur de vrais Avertissements. Par exemple, Optional.empty() renvoie un singleton pour éviter l'allocation d'options vides qui ne stockent pas de valeur.

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

Ce casting est sûr, comme le la valeur stockée dans un optionnel vide ne peut pas être récupérée, il n'y a donc aucun risque d'exceptions de conversion de classe inattendues.

Pour autant que je sache, pour l'instant cela a à voir avec la suppression des avertissements sur les génériques; les génériques sont une nouvelle construction de programmation non supportée dans les versions JDK antérieures à JDK 5, donc tout mélange des anciennes constructions avec les nouvelles pourrait poser des résultats inattendus.

Le compilateur avertit le programmeur à ce sujet, mais si le programmeur le sait déjà, il peut désactiver ces avertissements redoutés en utilisant SuppressWarnings.