À quoi servent les constructeurs génériques en Java ?

Question

Comme tout le monde le sait, vous pouvez avoir une classe générique en Java en utilisant des arguments de type :

class Foo<T> {
    T tee;
    Foo(T tee) {
        this.tee = tee;
    }
}

Mais vous pouvez aussi avoir un générique constructeurs c'est-à-dire des constructeurs qui reçoivent explicitement leurs propres arguments de type générique, par exemple :

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

J'ai du mal à comprendre le cas d'utilisation. Qu'est-ce que cette fonctionnalité me permet de faire ?

Answer 1

Le cas d'utilisation auquel je pense pourrait être que quelqu'un veut un objet qui hérite de 2 types. Par exemple, il implémente 2 interfaces :

public class Foo {

    public <T extends Bar & Baz> Foo(T barAndBaz){
        barAndBaz.barMethod();
        barAndBaz.bazMethod();
    }
}

Bien que je ne l'aie jamais utilisé en production.

Answer 2

Il est clair dans l'exemple que vous avez fourni que U ne joue aucun rôle dans le constructeur de la classe, puisqu'il devient effectivement un Object au moment de l'exécution :

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

Mais supposons que je veuille que mon constructeur n'accepte que les types qui étendent une autre classe ou interface, comme indiqué ci-dessous :

class Foo<T extends Baz> {
    <U extends Bar> Foo(U u) {
        // I must be a Bar!
    }
}

Remarquez que la classe utilise déjà un type générique différent ; cela vous permet d'utiliser un type générique distinct, sans rapport avec la définition de la classe.

D'accord, je n'ai jamais utilisé quelque chose comme ça, et je ne l'ai jamais vu en service, mais c'est possible !

Answer 3

Qu'est-ce que cette fonction me permet de faire ?

Il y a au moins trois deux choses qu'il vous permet de faire et que vous ne pourriez pas faire autrement :

1. exprimer des relations entre les types d'arguments, par exemple :

   class Bar {
       <T> Bar(T object, Class<T> type) {
           // 'type' must represent a class to which 'object' is assignable,
           // albeit not necessarily 'object''s exact class.
           // ...
       }
   }

2. <br />

3. Comme @Lino l'a observé en premier lieu, elle permet d'exprimer que les arguments doivent être compatibles avec une combinaison de deux ou plusieurs types non liés (ce qui peut avoir un sens lorsque tous les types sauf un au plus sont des types d'interface). Voir la réponse de Lino pour un exemple.

Answer 4

En fait, ce constructeur

class Bar {
    <U> Bar(U you) {
        // Why!?
    }
}

est comme un méthode générique . Cela aurait beaucoup plus de sens si vous aviez plusieurs arguments de constructeur comme ceci :

class Bar {
    <U> Bar(U you, List<U> me) {
        // Why!?
    }
} 

Vous pourriez alors appliquer la contrainte selon laquelle ils ont le même temps avec le compilateur. Sans faire de U un générique pour toute la classe.

Answer 5

Parce que ce type générique non lié s'efface pour Object cela reviendrait à passer Object dans votre constructeur :

public class Foo {
    Object o;

    public Foo(Object o) {
        this.o = o;
    }
}

...mais comme passer un blanc Object à moins que vous ne fassiez quelque chose astucieux mais cela n'a guère de valeur pratique.

Vous voyez des avantages et des gains si vous passez en lié génériques à la place, ce qui signifie que vous pouvez réellement avoir des garanties autour du type qui vous intéresse.

public class Foo<T extends Collection<?>> {
    T collection;
    public Foo(T collection) {
        this.collection = collection;
    }
}

En fait, il s'agit plus d'une question de flexibilité que de quelque chose de révolutionnaire. Si vous voulez avoir la flexibilité de passer dans une catégorie spécifique de types, alors vous avez le pouvoir de le faire ici. Si vous Ne le fais pas. alors il n'y a pas de problème avec les classes standard. Il est simplement là pour votre commodité, et puisque l'effacement de type est toujours une chose, un générique non lié est le même (et a la même utilité) que passer Object .