Esercizi sulle Annotazioni in Java

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'annotazione
import 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'annotazione
import 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'annotazione
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
}

// Utilizzo dell'annotazione
public 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'annotazione
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface DefaultValue {
    String value();
}

// Utilizzo dell'annotazione
public 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'annotazione
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Version {
    String value() default "1.0";
}

// Utilizzo dell'annotazione
@Version
public 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'annotazione
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface NotNull {
}

// Utilizzo dell'annotazione
public 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'annotazione
import 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'annotazione
import 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 gestione
public 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'enum
import java.lang.annotation.*;

enum Livello {
    ALTO, MEDIO, BASSO
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Priorità {
    Livello livello() default Livello.MEDIO;
}

// Utilizzo dell'annotazione
public 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'annotazione
import 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());
    }
}