Que signifie <T> (crochets angulaires) en Java?

J'étudie actuellement Java et j'ai récemment été déconcerté par les crochets (<>). Que signifient-ils exactement?

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

Qu'est-ce que cela <T>signifie? Cela signifie-t-il que je peux créer un objet de type T?

<T>est un générique et peut généralement être lu comme "de type T". Cela dépend du type à gauche de <> ce que cela signifie réellement.

Je ne sais pas ce qu'est un Poolou PoolFactory, mais vous mentionnez également ArrayList<T>, qui est une classe Java standard, donc je vais en parler.

Habituellement, vous ne verrez pas "T" là-dedans, vous verrez un autre type. Donc, si vous voyez ArrayList<Integer>par exemple, cela signifie «An ArrayListof Integers». De nombreuses classes utilisent des génériques pour contraindre le type des éléments dans un conteneur, par exemple. Un autre exemple est HashMap<String, Integer>, qui signifie «une carte avec des Stringclés et des Integervaleurs».

Votre exemple de Pool est un peu différent, car vous définissez ici une classe. Donc, dans ce cas, vous créez une classe que quelqu'un d'autre pourrait instancier avec un type particulier à la place de T. Par exemple, je pourrais créer un objet de type en Pool<String>utilisant votre définition de classe. Cela signifierait deux choses:

• My Pool<String>aurait une interface PoolFactory<String>avec une createObjectméthode qui retourne Strings.
• En interne, le Pool<String>contiendrait un ArrayListdes chaînes.

C'est une excellente nouvelle, car à un autre moment, je pourrais venir et créer un Pool<Integer>qui utiliserait le même code, mais qui aurait Integerpartout où vous voyez Tdans la source.

C'est vraiment simple. C'est une nouvelle fonctionnalité introduite dans J2SE 5 . La spécification de crochets angulaires après le nom de la classe signifie que vous créez un type de données temporaire qui peut contenir n'importe quel type de données.

Exemple:

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);
    }
}

Au lieu de cela <T>, vous pouvez écrire n'importe quoi et cela fonctionnera de la même manière. Essayez d'écrire <ABC>à la place de <T>.

C'est juste pour plus de commodité:

• <T> est appelé tout type
• <E> comme type d'élément
• <N> comme type de nombre
• <V> comme valeur
• <K> comme clé

Mais vous pouvez le nommer comme vous le souhaitez, cela n'a pas vraiment d'importance.

De plus, Integer, String, Booleanetc sont des classes wrapper de Java qui aident à la vérification des types lors de la compilation. Par exemple, dans le code ci-dessus, objest de type String, vous ne pouvez donc pas y ajouter d'autre type (essayez obj.add(1), cela enverra une erreur). De même, obj1est du Integertype, vous ne pouvez pas y ajouter d'autre type (essayez obj1.add("hello"), l'erreur sera là).

Il est lié aux génériques en java. Si j'ai mentionné ArrayList<String>cela signifie que je ne peux ajouter qu'un objet de type String à cet ArrayList.

Les deux principaux avantages des génériques en Java sont:

1. La réduction du nombre de lancers dans votre programme, ce qui réduit le nombre de bogues potentiels dans votre programme.
2. Améliorer la clarté du code

est appelé un type générique. Vous pouvez instancier un pool d'objets comme ceci:

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

Le paramètre générique ne peut être qu'un type référence. Vous ne pouvez donc pas utiliser de types primitifs comme int ou double ou char ou d'autres types primitifs.

<>est utilisé pour indiquer les génériques en Java.

Test un paramètre de type dans cet exemple. Et non: l'instanciation est l'une des rares choses que vous ne pouvez pas faire T.

Outre le didacticiel lié ci-dessus, la FAQ d'Angelika Langers Generics est une excellente ressource sur le sujet.

Les classes génériques sont un type de classe qui prend un type de données comme paramètre lors de sa création. Ce type de paramètre est spécifié en utilisant les supports d'angle et le type peut changer chaque fois une nouvelle instance de la classe est instancié. Par exemple, créons une ArrayList pour les objets Employee et une autre pour les objets Company

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

Vous remarquerez que nous utilisons la même classe ArrayList pour créer les deux listes et que nous passons le type Employé ou Entreprise à l'aide de crochets angulaires. Avoir une classe générique capable de gérer plusieurs types de données réduit le nombre de classes qui effectuent des tâches similaires. Les génériques aident également à réduire les bogues en donnant à tout un type fort qui aide le compilateur à signaler les erreurs. En spécifiant un type pour ArrayList, le compilateur lèvera une erreur si vous essayez d'ajouter un employé à la liste Société ou vice versa.