Esercizi sui Generics in Java

Ecco degli esercizi con soluzione per praticare l’uso dei Generics in Java.

Esercizio 1: Classe Generica Semplice

Creare una classe generica `Box` che può contenere un oggetto di qualsiasi tipo.

public class Box<T> {
    private T contenuto;

    public void setContenuto(T contenuto) {
        this.contenuto = contenuto;
    }

    public T getContenuto() {
        return contenuto;
    }

    public static void main(String[] args) {
        Box<String> boxStringa = new Box<>();
        boxStringa.setContenuto("Ciao");
        System.out.println("Contenuto: " + boxStringa.getContenuto());

        Box<Integer> boxIntero = new Box<>();
        boxIntero.setContenuto(123);
        System.out.println("Contenuto: " + boxIntero.getContenuto());
    }
}

Esercizio 2: Metodo Generico

Creare un metodo generico che accetta un parametro di qualsiasi tipo e lo stampa.

public class MetodoGenerico {
    public static <T> void stampa(T elemento) {
        System.out.println("Elemento: " + elemento);
    }

    public static void main(String[] args) {
        stampa("Ciao");
        stampa(123);
        stampa(3.14);
    }
}

Esercizio 3: Generics con Più Tipi

Creare una classe generica `Coppia` che può contenere due oggetti di qualsiasi tipo.

public class Coppia<T, U> {
    private T primo;
    private U secondo;

    public Coppia(T primo, U secondo) {
        this.primo = primo;
        this.secondo = secondo;
    }

    public T getPrimo() {
        return primo;
    }

    public U getSecondo() {
        return secondo;
    }

    public static void main(String[] args) {
        Coppia<String, Integer> coppia = new Coppia<>("Ciao", 123);
        System.out.println("Primo: " + coppia.getPrimo());
        System.out.println("Secondo: " + coppia.getSecondo());
    }
}

Esercizio 4: Bounded Generics

Creare una classe generica che accetta solo tipi che estendono `Number`.

public class NumeroBox<T extends Number> {
    private T numero;

    public NumeroBox(T numero) {
        this.numero = numero;
    }

    public T getNumero() {
        return numero;
    }

    public static void main(String[] args) {
        NumeroBox<Integer> boxIntero = new NumeroBox<>(123);
        System.out.println("Numero: " + boxIntero.getNumero());

        NumeroBox<Double> boxDouble = new NumeroBox<>(3.14);
        System.out.println("Numero: " + boxDouble.getNumero());
    }
}

Esercizio 5: Wildcard con Upper Bound

Utilizzare una wildcard con upper bound per accettare una lista di elementi che sono sottotipi di `Number`.

import java.util.ArrayList;
import java.util.List;

public class WildcardUpperBound {
    public static void sommaNumeri(List<? extends Number> lista) {
        double somma = 0;
        for (Number numero : lista) {
            somma += numero.doubleValue();
        }
        System.out.println("Somma: " + somma);
    }

    public static void main(String[] args) {
        List<Integer> listaInteri = new ArrayList<>();
        listaInteri.add(1);
        listaInteri.add(2);
        listaInteri.add(3);
        sommaNumeri(listaInteri);

        List<Double> listaDouble = new ArrayList<>();
        listaDouble.add(1.1);
        listaDouble.add(2.2);
        listaDouble.add(3.3);
        sommaNumeri(listaDouble);
    }
}

Esercizio 6: Wildcard con Lower Bound

Utilizzare una wildcard con lower bound per accettare una lista di elementi che sono supertipi di `Integer`.

import java.util.ArrayList;
import java.util.List;

public class WildcardLowerBound {
    public static void aggiungiNumeri(List<? super Integer> lista) {
        for (int i = 1; i <= 5; i++) {
            lista.add(i);
        }
    }

    public static void main(String[] args) {
        List<Number> listaNumeri = new ArrayList<>();
        aggiungiNumeri(listaNumeri);
        System.out.println("Lista: " + listaNumeri);
    }
}

Esercizio 7: Generics e Ereditarietà

Creare una classe generica `Contenitore` con un metodo che accetta un parametro generico e stampare il contenuto.

public class Contenitore<T> {
    private T contenuto;

    public void setContenuto(T contenuto) {
        this.contenuto = contenuto;
    }

    public T getContenuto() {
        return contenuto;
    }

    public static void main(String[] args) {
        Contenitore<String> contenitoreStringa = new Contenitore<>();
        contenitoreStringa.setContenuto("Ciao mondo");
        System.out.println("Contenuto: " + contenitoreStringa.getContenuto());

        Contenitore<Integer> contenitoreIntero = new Contenitore<>();
        contenitoreIntero.setContenuto(42);
        System.out.println("Contenuto: " + contenitoreIntero.getContenuto());
    }
}

Esercizio 8: Metodi Generici con Tipi Multipli

Creare un metodo generico che accetta due parametri di tipi diversi e li stampa.

public class MetodoGenericoMultiplo {
    public static <T, U> void stampa(T primo, U secondo) {
        System.out.println("Primo: " + primo);
        System.out.println("Secondo: " + secondo);
    }

    public static void main(String[] args) {
        stampa("Ciao", 123);
        stampa(3.14, "Mondo");
    }
}