Java Language Annotations intégrées


Exemple

L'édition Standard de Java comporte des annotations prédéfinies. Vous n'avez pas besoin de les définir vous-même et vous pouvez les utiliser immédiatement. Ils permettent au compilateur de permettre une vérification fondamentale des méthodes, des classes et du code.

@Passer outre

Cette annotation s'applique à une méthode et dit que cette méthode doit remplacer une méthode de superclasse ou implémenter une définition de méthode de superclasse abstraite. Si cette annotation est utilisée avec un autre type de méthode, le compilateur générera une erreur.

Superclasse en béton

public class Vehicle {
   public void drive() {
        System.out.println("I am driving");
   }
}

class Car extends Vehicle {
    // Fine
    @Override
    public void drive() {
        System.out.prinln("Brrrm, brrm");
    }
}

Classe abstraite

abstract class Animal  {
   public abstract void makeNoise(); 
}

class Dog extends Animal {
    // Fine
    @Override
    public void makeNoise() {
        System.out.prinln("Woof");
    }
}

Ne marche pas

class Logger1 {
    public void log(String logString) {
        System.out.prinln(logString);
    }
}

class Logger2 {
    // This will throw compile-time error. Logger2 is not a subclass of Logger1. 
    // log method is not overriding anything
    @Override
    public void log(String logString) {
        System.out.println("Log 2" + logString);
    }
}

L'objectif principal est de détecter les erreurs de frappe, où vous pensez que vous écrasez une méthode, mais en en définissant une nouvelle.

class Vehicle {
   public void drive() {
        System.out.println("I am driving");
   }
}

class Car extends Vehicle {
    // Compiler error. "dirve" is not the correct method name to override.
    @Override
    public void dirve() {
        System.out.prinln("Brrrm, brrm");
    }
}

Notez que la signification de @Override a changé avec le temps:

  • Dans Java 5, cela signifiait que la méthode annotée devait remplacer une méthode non abstraite déclarée dans la chaîne de la superclasse.
  • A partir de Java 6, il est également satisfait si la méthode annotée implémente une méthode abstraite déclarée dans la hiérarchie des classes / interfaces des classes.

(Cela peut occasionnellement poser problème lors du portage du code vers Java 5.)

@Précis

Cela marque la méthode comme obsolète. Il peut y avoir plusieurs raisons à cela:

  • l'API est imparfaite et difficile à réparer,

  • l'utilisation de l'API est susceptible de conduire à des erreurs,

  • l’API a été remplacée par une autre API,

  • l'API est obsolète,

  • l'API est expérimentale et est sujette à des modifications incompatibles,

  • ou toute combinaison de ce qui précède.

La raison spécifique de l'abandon se trouve généralement dans la documentation de l'API.


L'annotation provoquera une erreur du compilateur si vous l'utilisez. Les IDE peuvent également mettre en évidence cette méthode d'une manière ou d'une autre

class ComplexAlgorithm {
    @Deprecated
    public void oldSlowUnthreadSafeMethod() {
        // stuff here
    }
    
    public void quickThreadSafeMethod() {
        // client code should use this instead
    }
}

@Supprimer les avertissements

Dans presque tous les cas, lorsque le compilateur émet un avertissement, l'action la plus appropriée consiste à corriger la cause. Dans certains cas (code Generics utilisant du code pré-générique non sécurisé, par exemple), cela peut ne pas être possible et il est préférable de supprimer les avertissements que vous attendez et que vous ne pouvez pas corriger. Vous pouvez donc voir plus clairement les avertissements inattendus.

Cette annotation peut être appliquée à une classe, une méthode ou une ligne entière. Il prend la catégorie d'avertissement comme paramètre.

@SuppressWarnings("deprecation")
public class RiddledWithWarnings {
    // several methods calling deprecated code here
}

@SuppressWarning("finally")
public boolean checkData() {
    // method calling return from within finally block
}

Il est préférable de limiter la portée de l'annotation autant que possible pour éviter la suppression des avertissements inattendus. Par exemple, en limitant la portée de l'annotation à une seule ligne:

ComplexAlgorithm algorithm = new ComplexAlgorithm();
@SuppressWarnings("deprecation") algoritm.slowUnthreadSafeMethod(); 
// we marked this method deprecated in an example above

@SuppressWarnings("unsafe") List<Integer> list = getUntypeSafeList(); 
// old library returns, non-generic List containing only integers

Les avertissements pris en charge par cette annotation peuvent varier d'un compilateur à l'autre. Seuls les avertissements unchecked et deprecation sont spécifiquement mentionnés dans le JLS. Les types d'avertissement non reconnus seront ignorés.

@SafeVarargs

En raison de l'effacement de type, la void method(T... t) sera convertie en void method(Object[] t) ce qui signifie que le compilateur n'est pas toujours en mesure de vérifier que l'utilisation de varargs est de type sécurisé. Par exemple:

private static <T> void generatesVarargsWarning(T... lists) {

Il existe des cas où l'utilisation est sûre, auquel cas vous pouvez annoter la méthode avec l'annotation SafeVarargs pour supprimer l'avertissement. Cela cache évidemment l'avertissement si votre utilisation est dangereuse aussi.

@Interface fonctionnelle

C'est une annotation facultative utilisée pour marquer une interface fonctionnelle. Cela amènera le compilateur à se plaindre s'il ne se conforme pas à la spécification de FunctionalInterface (possède une seule méthode abstraite)

@FunctionalInterface
public interface ITrade {
  public boolean check(Trade t);
}

@FunctionalInterface
public interface Predicate<T> {
  boolean test(T t);
}