Iterator, Comparable, Comparator e Class parametriche – Lezione 23 di Java Avanzato

Una classe parametrica può essere utilizzata anche nella sua versione grezza senza parametri di tipo. Riprendendo la classe Pair della scorsa lezione, è possibile scrivere:

  Pair p = new Pair("a1", "a2");

L’utilizzo delle versioni grezze (ovvero senza parametri di tipo) è sconsigliato, utilizzando i parametri di tipo abbiamo la possibilità di scoprire molti errori già a tempo di compilazione. In genere i compilatori restituiscono un warning perché le versioni grezze delle classi non dovrebbero essere utilizzate quando si scrivere del codice nuovo. La loro esistenza è dovuto solo per problemi di compatibilità con codice vecchio in cui le classi parametriche ancora non erano state introdotte. La versione grezza di una classe perde tutti i vantaggi introdotti dai generics come gli errori a compilazione, i casting e il riutilizzo in modo sicuro del codice.

Le versioni di Iterator e Iterable parametriche

Sia l’interfaccia Iterator che Iterable sono parametriche. La prima è così definita:

  public interface Iterator<E> {
    public E next();
    public boolean hasNext();
    public void remove();
  }

Con la versione parametrica non saremo più costretti ad effettuare il casting con gli oggetti ricevuti dal metodo next.

Come implementare un’interfaccia parametrica? Esistono due modi per implementare un’interfaccia parametrica:

  1. Implementando una versione specifica dell’interfaccia:

    public class A implements Iterator<String>{...}
  2. Attraverso una classe parametrica che implementa la corrispondente versione di quell’interfaccia:
    public class A implements Iterator<T>{...}

L’interfaccia Iterable nella sua versione parametrica è definita nel seguente modo:

  public interface Iterable<E> {
    public Iterator <E> iterator();
  }

La versione di Comparable e Comparator parametrica

Anche le interfacce Comparable e Comparator sono parametriche, entrambe utilizzano un unico parametro di tipo. Comparable per l’ordinale naturale sarà:

  public interface Comparable<T> {
    public int compareTo(T x);
  }

Il parametro di tipo consente di specificare il tipo di oggetto che bisogna confrontare. Per quanto riguarda Comparator, la versione parametrica è la seguente:

  public interface Comparator<T> {
    public int compare(T x, T y);
  }

La classe LinkedList parametrica

La versione parametrica di LinkedList prevede i seguenti metodi con i parametri di tipo:

  public class LinkedList<E> implements Iterable<E> {
    public void addFirst(E elem){...}
    public void addLast(E elem){...}
    public E removeFirst(){...}
    public E removeLast(){...}
  }

Con i parametri di tipo è possibile utilizzare una LinkedList di qualsiasi tipo istanziandola con tipi differenti.

La versione parametrica della classe Class

Anche la classe Class che consente ai programmi di investigare a runtime sui tipi effettivi degli oggetti utilizza i parametri di tipo:

  public class <T>

Uno dei suoi metodi è newInstance:

  public T newInstance()

Questo metodo restituisce un nuovo oggetto della classe su cui è invocato. Finalmente non avremo più Object ma il vero e proprio tipo effettivo della classe.

Indice Lezione PrecedenteLezione Successiva

Pubblicato in Design Pattern, Guide, Java, Programmazione Taggato con: , , , , , , , , ,

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

*