Quand j'ai une interface
public class Bar implements Foo<Bar> {
Bar someMethod() {
return new Bar();
}
}
4 Réponses :
Je ne peux pas soumettre un simple "n °" Sur ce site (corps trop court), alors voilà. P>
NO. P>
Non, vous ne pouvez pas vous référer à la classe d'implémentation. Le mieux que vous puissiez faire est de: faisant cela, vous pouvez être sûr que Même avec une définition d'interface comme ceci: p> , puis vous pouvez définir une classe la question initiale était si vous pouviez vous préparer à la Utilisation de l'interface comme Angelika Langer donne Une belle explication de Comment puis-je décrypter "Enum SOMEMETHOD () code> renvoie un objet qui implémente foo code>. p>
bar2 code> p> bar code> qui implémente foo code> mais ne retourne pas bar code> mais bar2 code>: p> bar code> a fait. p>
Parce que vous n'avez pas répondu à la question de l'OP. La question de l'OP a posé: Comment pouvez-vous vous assurer que avec un type bar code> qui implémentée foo code>, il ne pouvait implémenter que "code> foo foo java.util.enum code>, par exemple.
Parce que tu as tort? La réponse suivante ci-dessous montre un lien vers un motif et des exemples de modèles récurrents de travail garantissant que la classe d'implémentation utilise la classe de base, par opposition à n'importe quelle ancienne classe ..
Pourquoi cela est accepté, c'est au-delà de moi. L'OP devrait vraiment clarifier sa question plus réelle.
J'ai ajouté un exemple pourquoi la réponse de @ Chris-Jester-Young n'est pas meilleure que la mienne.
Vous avez raison, merci pour le contre-exemple. Je vais mettre à jour ma réponse. Il y a toujours une différence entre l'utilisation d'utiliser > Code> contre
Cette réponse est correcte et la réponse acceptée est incorrecte.
Ceci ne peut pas être fait à cause de Effacement de type A >. EDIT: P> J'ai voté, voici plus d'explication: p> t code> de ci-dessus est Disponible en temps d'exécution, il ne peut donc pas être vérifié. Cependant, on pourrait une annotation personnalisée qui pourrait appliquer cela. P> p>
Oui, je t'ai dit. Je ne parlais pas de vérification de type d'exécution - bien sûr, qui est impossible à Java - mais la question de l'OP ne pose pas de question à ce sujet.
public interface Recur<T extends Recur<T>> {
T foo();
}
class A implements Recur<B> {
@Override
public B foo() {
return new B();
}
}
class B implements Recur<A> {
@Override
public A foo() {
return new A();
}
}
Pour la réponse: +1; pour la descendre des autres réponses: -1; Pour l'admettre: +1 = +1