Java Language Annotazioni incorporate


Esempio

La Standard Edition di Java viene fornita con alcune annotazioni predefinite. Non è necessario definirli da soli e puoi utilizzarli immediatamente. Permettono al compilatore di abilitare alcuni controlli fondamentali su metodi, classi e codici.

@Oltrepassare

Questa annotazione si applica a un metodo e afferma che questo metodo deve sovrascrivere il metodo di una superclasse o implementare una definizione di metodo di una superclasse astratta. Se questa annotazione viene utilizzata con qualsiasi altro tipo di metodo, il compilatore genererà un errore.

Superclasse concreta

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 astratta

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

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

Non funziona

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

Lo scopo principale è catturare l'errore di digitazione, in cui si pensa di ignorare un metodo, ma in realtà ne sta definendo uno nuovo.

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");
    }
}

Nota che il significato di @Override è cambiato nel tempo:

  • In Java 5, significava che il metodo annotato doveva sovrascrivere un metodo non astratto dichiarato nella catena della superclasse.
  • Da Java 6 in poi, è anche soddisfatto se il metodo annotato implementa un metodo astratto dichiarato nella gerarchia superclasse / interfaccia delle classi.

(Ciò può causare occasionalmente problemi quando si esegue il back-porting del codice su Java 5.)

@deprecated

Questo contrassegna il metodo come deprecato. Ci possono essere diverse ragioni per questo:

  • l'API è difettosa e non è pratico da risolvere,

  • l'utilizzo dell'API può causare errori,

  • l'API è stata sostituita da un'altra API,

  • l'API è obsoleta,

  • l'API è sperimentale ed è soggetta a modifiche incompatibili,

  • o qualsiasi combinazione di quanto sopra.

Il motivo specifico della deprecazione si trova di solito nella documentazione dell'API.


L'annotazione farà sì che il compilatore emetta un errore se lo si utilizza. Gli IDE possono anche evidenziare questo metodo in qualche modo come deprecato

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

@SuppressWarnings

In quasi tutti i casi, quando il compilatore emette un avviso, l'azione più appropriata è quella di correggere la causa. In alcuni casi (codice generics che utilizza un codice di pre-generica non sicuro, ad esempio) questo potrebbe non essere possibile ed è meglio sopprimere quegli avvertimenti che ci si aspetta e non è possibile correggere, in modo da poter vedere più chiaramente gli avvertimenti inattesi.

Questa annotazione può essere applicata a un'intera classe, metodo o linea. Prende la categoria di avvertimento come parametro.

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

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

È preferibile limitare il più possibile l'ambito dell'annotazione, per evitare che vengano eliminati anche gli avvisi imprevisti. Ad esempio, confinando l'ambito dell'annotazione su una singola riga:

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

Gli avvertimenti supportati da questa annotazione possono variare da compilatore a compilatore. Solo gli avvertimenti unchecked e di deprecation sono specificatamente menzionati nel JLS. I tipi di avvertimento non riconosciuti verranno ignorati.

@SafeVarargs

A causa della cancellazione dei tipi, il void method(T... t) verrà convertito in void method(Object[] t) il che significa che il compilatore non è sempre in grado di verificare che l'uso di varargs sia sicuro per il tipo. Per esempio:

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

Esistono casi in cui l'utilizzo è sicuro, nel qual caso è possibile annotare il metodo con l'annotazione di SafeVarargs per sopprimere l'avviso. Ovviamente questo nasconde l'avviso se il tuo uso non è sicuro.

@FunctionalInterface

Questa è un'annotazione opzionale utilizzata per contrassegnare una FunctionalInterface. Fa sì che il compilatore si lamenti se non è conforme alle specifiche di FunctionalInterface (ha un singolo metodo astratto)

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

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