Una delle novità che sicuramente avrà grosso impatto su Java è l'introduzione delle annotazioni, presenti da Java 5 in poi. Ma cosa sono le annotazioni?

Potremmo dire che le annotazioni sono un modo per rendere più espressivo il nostro codice, anche e soprattutto per il compilatore. Infatti, le annotazioni sono metadati (vale a dire informazioni sulle informazioni), che, per esempio, possono servire a specificare vincoli e controlli sui dati, oppure a far sì che questi vincoli siano interpretabili dalla JVM, dal compilatore o da Javadoc, e così via... Lo sviluppatore può definire le sue proprie annotazioni, e creare processori di annotazioni ad-hoc per la sua applicazione. La sintassi per definire le annotazioni è la seguente:

public @interface annotazione{ //La parola chiave @interface serve a dichiarare un'annotazione
    String valore1();
    String valore2();
}

public class Prova{
    @annotazione(
        valore1 = "ciao"
        valore2 = "pippo"
    )
    public void metodoAnnotato(){}
}

Abbiamo dichiarato un'annotazione chiamata "annotazione" con due parametri di tipo stringa, e poi abbiamo dichiarato un metodo (metodoAnnotato) annotato con quell'annotazione, come se fosse uno specificatore d'accesso. Qual'è lo scopo di tutto questo? E' semplice: in un'altra parte del codice, tramite Reflection, si possono ottenere tutti i metodi, classi o variabili marcati con una determinata annotazione ed eseguire delle azioni su di essi (pubblicarli su Internet, formattarne i risultati, ecc.): le applicazioni delle annotazioni sono virtualmente infinite. Certo, è difficile creare e utilizzare in modo pratico annotazioni personalizzate (senza contare che ce ne sono diversi tipi e che si possono annotare altre annotazioni :confused: ); ma, per noi comuni mortali :D, esistono le cosiddette "annotazioni standard", fornite col JDK, che sono in grado di aiutare non poco il programmatore. Esse sono: Deprecated, Override, e SuppressWarnings. 

L'annotazione @override può essere usata solo sui metodi e serve a indicare al compilatore che il metodo che segue è override di un altro metodo. Quindi, se per qualche motivo non lo è (per esempio per errore di battitura e quindi alterazione del nome), viene segnalato tramite un warning a compile-time, evitando ore e ore di debug per uno stupido errore. Per esempio:

@override
public void metodoOverridato(){}

L'annotazione @deprecated, come dice il nome, sta ad indicare che il metodo che segue è deprecato; il suo utilizzo è uguale a quello di @override.

L'annotazione @SuppressWarnings serve ad evitare che il compilatore lanci particolari tipi di warning. Esso prende come parametro il tipo di warning da sopprimere. Per esempio, se si vogliono sopprimere i checked warnings, basta fare così:

@SuppressWarnings({"checked"})
void metodo(){}

Questo è ciò che serve per un utilizzo basilare delle annotazioni (almeno quelle standard). Se ne volete sapere di più (spero di avervi invogliato :D), potete cercare altre informazioni sulla rete. In particolare, vi consiglio il capitolo sulle annotazioni del libro di Claudio De Sio, sono spiegate veramente bene.