Java génériques Génériques étend de 2 interfaces

Comment voulez-vous faire ce travail:

public class Frankenstein<T extends IHuman, IMonster>{
}

Sans faire

public interface Weirdo extends Ihuman, IMonster{
}

Modifier

Pourquoi ça ne marche pas?

public <T> void mapThis(
        Class<? extends MyClass<T>> key, Class<? extends T & IDisposable> value) {

}

Je suis compilateur de marquage de message Class<? extends T & IDisposable> comme une Erreur.

Double Possible de Java Génériques Wildcarding Avec Plusieurs Classes

InformationsquelleAutor Ilya Gazman | 2012-10-27

101

Reimeus l'a déjà souligné que ce que vous demandez dans votre montage n'est pas possible. J'aimerais développer un peu pourquoi.

On pourrait penser que vous pouvez utiliser les éléments suivants:
```
public <T, U extends T & IDisposable> void mapThis(
        Class<? extends MyClass<T>> key,
        Class<? extends U> value
) { ... }
```
En fait, c'est ce qui est venu à mon esprit quand j'ai vu ce post. Mais cela donne effectivement une erreur de compilateur:

un type de variable peut ne pas être suivi par d'autres limites

Pour m'aider à expliquer pourquoi, je voudrais citer un Oracle Blogs post par Victor Rudometov sur cette erreur:

Ce fait n'est pas toujours évident, mais c'est vrai. Le code suivant
ne devrait pas compiler:

interface I {}

class TestBounds <U, T extends U & I> {

}

Parce que JLS Chapitre 4
Les Types, les Valeurs et les Variables de la section 4.4 Type de Variables d'états: "L'
lié consiste soit un type d'une variable ou d'une classe ou d'une interface de type
T éventuellement suivie par d'autres types d'interface I₁ , ..., I_n.". Donc on
peut utiliser T s'étend U, T s'étend SomeClass & je, mais pas T s'étend U & je.
Cette règle s'applique à tous les cas, y compris le type des variables et des limites dans l'
les méthodes et les constructeurs.

Les raisons de cette restriction sont explorées dans un étroitement liées post: Pourquoi ne puis-je pas utiliser un argument de type dans un paramètre de type, avec de multiples limites?

Pour résumer, la restriction a été imposée afin de "s'opposent à certaines situations délicates de venir à l'existence" (JLS §4.9).

Ce genre de situations embarrassantes? Une réponse par Chris Povirk décrit un:
[Une raison pour laquelle la restriction est] la possibilité de spécifier des drogues illégales. Plus précisément, l'extension d'une interface générique, deux fois avec des paramètres différents. Je ne peux pas venir avec un non-exemple artificiel, mais:
```
/** Contains a Comparator<String> that also implements the given type T. */
class StringComparatorHolder<T, C extends T & Comparator<String>> {
  private final C comparator;
  //...
}

void foo(StringComparatorHolder<Comparator<Integer>, ?> holder) { ... }
```
Maintenant holder.comparator est un Comparator<Integer> et un Comparator<String>.
Chris a aussi points à Soleil bug 4899305, qui était un bug contestation de cette restriction de langue. Il a été fermé parce que ne sera pas Corrigé avec le commentaire suivant:

Si une variable de type pourrait être suivie par les variables de type ou par (éventuellement
paramétrable) interfaces, il y aurait probablement plus mutuellement
récursif de type de variables, qui sont très difficiles à manipuler. Les choses
sont déjà compliqué quand une limite est simplement un type paramétré,
par exemple,<S,R extends Comparable<S>>. Par conséquent, les limites ne sont pas va
changer maintenant. Les deux javac et Eclipse acceptez que S&T et
S&Comparable<S> sont illégales.

De sorte que ces sont les raisons de la restriction. L'adressage des méthodes génériques spécifiquement (ce que votre question concerne), je voudrais en outre souligner que l'inférence de type, en théorie, la cause de ces limites inutile de toute façon.

Si nous réexaminer le type des paramètres déclarés dans l'hypothétique signature ci-dessus:
```
<T, U extends T & IDisposable>
```
En supposant que l'appelant n'est pas de spécifier explicitement T et U, cela peut être réduit à ce qui suit:
```
<T, U extends Object & IDisposable>
```
Ou tout simplement cette (différence subtile, mais c'est un autre sujet):
```
<T, U extends IDisposable>
```
C'est parce que T n'ont pas de limites, pour n'importe quel type d'arguments sont passés, T peut toujours résoudre à Object à tout le moins, et alors peut U.

Nous allons revenir en arrière et dire T est bornée:
```
<T extends Foo, U extends T & IDisposable>
```
Cela peut être réduite de la même façon (Foo pourrait être une classe ou une interface):
```
<T extends Foo, U extends Foo & IDisposable>
```
Basant sur ce raisonnement, la syntaxe que vous essayez d'atteindre est inutile autant que la restriction de l'appelant à plus d'arguments spécifiques.

Pré-Java 8 addendum:

Avant Java 8, il y est un cas d'utilisation pour ce que vous essayez de faire. En raison d'une limitation de la façon dont le compilateur déduit méthode générique paramètres de type, mon raisonnement ci-dessus pour sortir de la fenêtre. Prendre la méthode générique:
```
class MyClass {
    static <T> void foo(T t1, T t2) { }
}
```
C'est une erreur de débutant d'essayer de faire une méthode qui prend deux paramètres de la "même type". Bien sûr, c'est inutile, parce que de la façon dont l'héritage fonctionne:
```
MyClass.foo("asdf", 42); //legal
```
Ici, T est déduit d' Object - ce qui correspond à plus tôt de raisonnement sur la simplification de la mapThis des paramètres de type. Vous devez spécifier manuellement les paramètres de type de commande à atteindre le type de vérification:
```
MyClass.<String>foo("asdf", 42); //compiler error
```
Cependant, et c'est là que votre cas d'utilisation commence à rentrer, c'est une autre affaire avec plusieurs paramètres de type d'échelonnement des limites:
```
class MyClass {
    static <T, U extends T> void foo(T t, U u) { }
}
```
Maintenant cet appel erreurs:
```
MyClass.foo("asdf", 42); //compiler error
```
Les tables ont tourné - nous avons manuellement détendre les paramètres de type pour la compiler:
```
MyClass.<Object, Object>foo("asdf", 42); //legal
```
Ceci se produit en raison de la limitation façon dont le compilateur déduit de la méthode des paramètres de type. Pour cette raison, ce que tu voulais faire aurait effectivement eu une demande en limitant les arguments de l'appelant.

Toutefois, ce problème semble avoir été résolu dans Java 8, et MyClass.foo("asdf", 42) maintenant se compile sans erreur, (grâce à un Régent pour le signaler).
- Par la voie, MyClass.foo("asdf", 42) ne donne pas d'erreur de compilation avec <T, U extends T> limites dans Java 8.
- agréable de voir que le problème a été résolu. Mise à jour de ma réponse, merci!
- Bonne réponse, même si je ne partage pas moi-même. À mon avis c'est un défaut de conception du compilateur
InformationsquelleAutor Paul Bellora

J'ai juste pensé que je voudrais partager mon hack que j'utilise dans ces (assez rare) situations:

    /**
     * This is a type-checking method, which gets around Java's inability
     * to handle multiple bounds such as "V extends T & ContextAware<T>".
     *
     * @param value initial value, which should extends T
     * @param contextAware initial value, which should extend ContextAware<T>
     * @return a new proxy object
     */
    public T blah(T value, ContextAware<T> contextAware) {
        if (value != contextAware) {
            throw new IllegalArgumentException("This method expects the same object for both parameters.");
        }

        return blah(value);
    }

Donc, en exigeant le même objet pour chacune des limites en essayant de vous satisfaire, vous obtenez le type de compilation vérification et de l'objet unique qui s'occupe de tout. Certes, il est un peu bête de passer le même objet, pour chaque paramètre, mais je le fais dans mon "intérieur" code en toute sécurité et confortablement.

InformationsquelleAutor Ben

Vous devez vous connecter pour publier un commentaire.

Pré-Java 8 addendum: