Cosa significa <T> (parentesi angolari) in Java?

Attualmente sto studiando Java e recentemente sono stato sconcertato da parentesi angolari (<>). Cosa significano esattamente?

public class Pool<T>{
    public interface PoolFactory<T>{
        public T createObject();
    }
    this.freeObjects = new ArrayList<T>(maxsize)
}

Cosa <T>significa? Significa che posso creare un oggetto di tipo T?

<T>è un generico e di solito può essere letto come "di tipo T". Dipende dal tipo a sinistra di <> che cosa significa effettivamente.

Non so cosa sia Poolo PoolFactory, ma anche tu menzioni ArrayList<T>, che è una classe Java standard, quindi parlerò con quello.

Di solito, non vedrai "T" lì dentro, vedrai un altro tipo. Quindi, se vedi ArrayList<Integer>ad esempio, significa "An ArrayListof Integers". Molte classi usano generici per limitare il tipo di elementi in un contenitore, ad esempio. Un altro esempio è HashMap<String, Integer>, che significa "una mappa con Stringchiavi e Integervalori".

Il tuo esempio di Pool è un po 'diverso, perché lì stai definendo una classe. Quindi, in quel caso, stai creando una classe che qualcun altro potrebbe creare un'istanza con un particolare tipo al posto di T. Ad esempio, potrei creare un oggetto di tipo Pool<String>usando la definizione della tua classe. Ciò significherebbe due cose:

• Il mio Pool<String>avrebbe un'interfaccia PoolFactory<String>con un createObjectmetodo che restituisce Strings.
• Internamente, Pool<String>dovrebbe contenere una ArrayListstringa.

Questa è una grande notizia, perché in un altro momento, potrei venire a crearne uno Pool<Integer>che userebbe lo stesso codice, ma che abbia Integerovunque vedi Tnella fonte.

È davvero semplice È una nuova funzionalità introdotta in J2SE 5 . Specificare parentesi angolari dopo il nome della classe significa che si sta creando un tipo di dati temporaneo che può contenere qualsiasi tipo di dati.

Esempio:

class A<T>{
    T obj;
    void add(T obj){
        this.obj=obj;
    }
    T get(){
        return obj;
    }
}
public class generics {
    static<E> void print(E[] elements){
        for(E element:elements){
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        A<String> obj=new A<String>();
        A<Integer> obj1=new A<Integer>();
        obj.add("hello");
        obj1.add(6);
        System.out.println(obj.get());
        System.out.println(obj1.get());

        Integer[] arr={1,3,5,7};
        print(arr);
    }
}

Invece <T>, puoi effettivamente scrivere qualsiasi cosa e funzionerà allo stesso modo. Prova a scrivere <ABC>al posto di <T>.

Questo è solo per comodità:

• <T> viene indicato come qualsiasi tipo
• <E> come tipo di elemento
• <N> come tipo di numero
• <V> come valore
• <K> come chiave

Ma puoi nominarlo come vuoi, non importa.

Inoltre, Integer, String, Booleanecc sono classi wrapper di Java, che aiuto nel controllo dei tipi durante la compilazione. Ad esempio, nel codice sopra, objè di tipo String, quindi non è possibile aggiungere nessun altro tipo ad esso (provare obj.add(1), genererà un errore). Allo stesso modo, obj1è del Integertipo, non puoi aggiungere nessun altro tipo (prova obj1.add("hello"), l'errore sarà lì).

È legato ai generici di Java. Se ho detto ArrayList<String>questo significa che posso aggiungere solo l'oggetto di tipo String a tale ArrayList.

I due principali vantaggi dei generici in Java sono:

1. Ridurre il numero di cast nel tuo programma, riducendo così il numero di potenziali bug nel tuo programma.
2. Migliorare la chiarezza del codice

è chiamato un tipo generico. È possibile creare un'istanza di un pool di oggetti in questo modo:

PoolFactory<Integer> pool = new Pool<Integer>();

Il parametro generico può essere solo un tipo di riferimento. Quindi non puoi usare tipi primitivi come int o double o char o altri tipi primitivi.

<>è usato per indicare generici in Java.

Tè un parametro di tipo in questo esempio. E no: l'istanza è una delle poche cose con cui non puoi fare T.

Oltre al tutorial collegato sopra, le FAQ di Generics di Angelika Langers sono una grande risorsa sull'argomento.

Le classi generiche sono un tipo di classe che accetta un tipo di dati come parametro quando viene creato. Questo parametro di tipo viene specificato utilizzando parentesi angolari e il tipo può cambiare ogni volta che viene istanziata una nuova istanza della classe. Ad esempio, creiamo un ArrayList per gli oggetti Employee e un altro per gli oggetti Company

ArrayList<Employee> employees = new ArrayList<Employee>();
ArrayList<Company> companies = new ArrayList<Company>();

Noterai che stiamo usando la stessa classe ArrayList per creare entrambi gli elenchi e passiamo nel tipo Employee o Company utilizzando parentesi angolari. Avere una classe generica in grado di gestire più tipi di dati riduce la presenza di molte classi che svolgono attività simili. I generici aiutano anche a ridurre i bug dando a tutto un tipo forte che aiuta il compilatore a segnalare errori. Specificando un tipo per ArrayList, il compilatore genererà un errore se si tenta di aggiungere un dipendente all'elenco società o viceversa.