Que signifie (crochets d'angle) en Java?

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

Je ne sais pas ce qu'est un Pool ou 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 "Un ArrayList de Integer s." 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>, ce qui signifie "une carte avec des clés String et des valeurs Integer."

Votre exemple de pool est un peu différent, car vous êtes là définissant 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 Pool<String> en utilisant votre définition de classe. Cela signifierait deux choses:

• Mon Pool<String> aurait une interface PoolFactory<String> avec une méthode createObject qui renvoie String s.
• en Interne, le Pool<String> contiendrait un ArrayList de Chaînes de caractères.

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 aurait Integer partout où vous voyez T dans la source.

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 chaîne à cette ArrayList.

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

1. Réduire le nombre de casts dans votre programme, réduisant ainsi le nombre de bogues potentiels dans votre programme.
2. Amélioration de la clarté du code

C'est vraiment simple. C'est une nouvelle fonctionnalité introduite dans J2SE 5. Spécifier des 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 <T>, vous pouvez réellement écrire n'importe quoi et cela fonctionnera de la même manière. Essayez d'écrire <ABC> à la place de <T>.

Ceci est juste pour plus de commodité:

• <T> est appelé tout type
• <E> comme élément type
• {[6] } comme type de numéro
• <V> comme valeur
• <K> comme clé

Mais vous pouvez le nommer tout ce que vous voulez, cela n'a pas vraiment d'importance.

De plus, Integer, String, Boolean etc sont des classes wrapper de Java qui aident à vérifier les types lors de la compilation. Par exemple, dans le code ci-dessus, obj est de type String, vous ne pouvez donc pas y ajouter d'autre type (essayez obj.add(1), il émettra une erreur). De même, obj1 est du type Integer, vous ne pouvez pas en ajouter autre type (essayez obj1.add("hello"), l'erreur sera là).

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 de 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 génériques en Java.

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

En dehors du tutoriel lié ci-dessusAngelika Langers Generics FAQ est une excellente ressource sur le sujet.

Les classes génériques sont un type de classe qui prend un type de données en tant que paramètre lors de sa création. Ce paramètre de type est spécifié à l'aide de crochets et le type peut changer chaque fois qu'une nouvelle instance de la classe est instanciée. 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 transmettons le type Employé ou Entreprise à l'aide de crochets. 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 génère une erreur si vous essayez d'ajouter un employé à la liste de l'entreprise ou vice versa.