Esercizi sulle Annotazioni in Java
- Esercizio 1: Creazione di una Semplice Annotazione
- Esercizio 2: Annotazione con Più Elementi
- Esercizio 3: Annotazione di Metodi
- Esercizio 4: Annotazione di Campi
- Esercizio 5: Annotazione con Valore di Default
- Esercizio 6: Annotazione per Controllo dei Parametri
- Esercizio 7: Annotazione Ripetibile
- Esercizio 8: Annotazione con Classi
- Esercizio 9: Annotazione con Enums
- Esercizio 10: Annotazione per Documentazione
Ecco degli esercizi con soluzione per praticare l’uso delle annotazioni in Java.
Esercizio 1: Creazione di una Semplice Annotazione
Creare una semplice annotazione `@Info` con un elemento `value` e applicarla a una classe.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Info { String value();}
// Utilizzo dell'annotazione@Info("Questa è una classe di esempio")public class Esempio { public static void main(String[] args) { Info info = Esempio.class.getAnnotation(Info.class); System.out.println("Annotazione Info: " + info.value()); }}
Esercizio 2: Annotazione con Più Elementi
Creare un'annotazione `@Autore` con elementi `nome` e `data` e applicarla a una classe.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Autore { String nome(); String data();}
// Utilizzo dell'annotazione@Autore(nome = "Mario Rossi", data = "12/07/2024")public class Libro { public static void main(String[] args) { Autore autore = Libro.class.getAnnotation(Autore.class); System.out.println("Autore: " + autore.nome()); System.out.println("Data: " + autore.data()); }}
Esercizio 3: Annotazione di Metodi
Creare un'annotazione `@Test` e applicarla a un metodo.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)public @interface Test {}
// Utilizzo dell'annotazionepublic class TestEsempio {
@Test public void testMetodo() { System.out.println("Metodo di test eseguito"); }
public static void main(String[] args) throws Exception { for (Method method : TestEsempio.class.getMethods()) { if (method.isAnnotationPresent(Test.class)) { method.invoke(new TestEsempio()); } } }}
Esercizio 4: Annotazione di Campi
Creare un'annotazione `@DefaultValue` con un elemento `value` e applicarla a un campo.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.FIELD)public @interface DefaultValue { String value();}
// Utilizzo dell'annotazionepublic class Configurazione {
@DefaultValue("localhost") private String host;
public static void main(String[] args) throws Exception { Configurazione config = new Configurazione(); for (Field field : Configurazione.class.getDeclaredFields()) { if (field.isAnnotationPresent(DefaultValue.class)) { DefaultValue defaultValue = field.getAnnotation(DefaultValue.class); field.setAccessible(true); field.set(config, defaultValue.value()); } } System.out.println("Host: " + config.host); }}
Esercizio 5: Annotazione con Valore di Default
Creare un'annotazione `@Version` con un elemento `value` con valore di default.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Version { String value() default "1.0";}
// Utilizzo dell'annotazione@Versionpublic class Software { public static void main(String[] args) { Version version = Software.class.getAnnotation(Version.class); System.out.println("Versione: " + version.value()); }}
Esercizio 6: Annotazione per Controllo dei Parametri
Creare un'annotazione `@NotNull` e applicarla a un parametro di metodo, quindi verificare il valore del parametro a runtime.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.PARAMETER)public @interface NotNull {}
// Utilizzo dell'annotazionepublic class ValidaParametro {
public void stampa(@NotNull String messaggio) { if (messaggio == null) { throw new IllegalArgumentException("Il parametro non può essere null"); } System.out.println(messaggio); }
public static void main(String[] args) { ValidaParametro vp = new ValidaParametro(); vp.stampa("Ciao mondo"); // Questo funziona vp.stampa(null); // Questo lancerà un'eccezione }}
Esercizio 7: Annotazione Ripetibile
Creare un'annotazione `@Tag` che può essere applicata più volte allo stesso elemento.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)@Repeatable(Tags.class)public @interface Tag { String value();}
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Tags { Tag[] value();}
// Utilizzo dell'annotazione@Tag("Java")@Tag("Programmazione")public class Articolo { public static void main(String[] args) { Tag[] tags = Articolo.class.getAnnotationsByType(Tag.class); for (Tag tag : tags) { System.out.println("Tag: " + tag.value()); } }}
Esercizio 8: Annotazione con Classi
Creare un'annotazione `@Handler` con un elemento `handlerClass` e applicarla a una classe.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Handler { Class<?> handlerClass();}
// Utilizzo dell'annotazione@Handler(handlerClass = ArticoloHandler.class)public class Articolo { public static void main(String[] args) throws Exception { Handler handler = Articolo.class.getAnnotation(Handler.class); System.out.println("Handler class: " + handler.handlerClass().getName()); handler.handlerClass().getDeclaredMethod("handle").invoke(handler.handlerClass().getDeclaredConstructor().newInstance()); }}
// Classe di gestionepublic class ArticoloHandler { public void handle() { System.out.println("Handling article"); }}
Esercizio 9: Annotazione con Enums
Creare un'annotazione `@Priorità ` con un elemento `livello` di tipo `Enum` e applicarla a un metodo.
// Definizione dell'annotazione e dell'enumimport java.lang.annotation.*;
enum Livello { ALTO, MEDIO, BASSO}
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)public @interface Priorità { Livello livello() default Livello.MEDIO;}
// Utilizzo dell'annotazionepublic class Task {
@Priorità (livello = Livello.ALTO) public void taskImportante() { System.out.println("Task importante eseguito"); }
@Priorità public void taskNormale() { System.out.println("Task normale eseguito"); }
public static void main(String[] args) throws Exception { for (Method method : Task.class.getMethods()) { if (method.isAnnotationPresent(Priorità .class)) { Priorità priorità = method.getAnnotation(Priorità .class); System.out.println("Esecuzione " + method.getName() + " con priorità " + priorità .livello()); method.invoke(new Task()); }
} }}
Esercizio 10: Annotazione per Documentazione
Creare un'annotazione `@Documentazione` con elementi `autore` e `descrizione` e applicarla a una classe.
// Definizione dell'annotazioneimport java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Documentazione { String autore(); String descrizione();}
// Utilizzo dell'annotazione@Documentazione(autore = "Mario Rossi", descrizione = "Classe di esempio per documentazione")public class EsempioDocumentato { public static void main(String[] args) { Documentazione doc = EsempioDocumentato.class.getAnnotation(Documentazione.class); System.out.println("Autore: " + doc.autore()); System.out.println("Descrizione: " + doc.descrizione()); }}