Qui étend les interfaces? Et pourquoi?

AFAIK, mes extendsclasses et implementsinterfaces parentales . Mais je rencontre une situation où je ne peux pas l'utiliser implements SomeInterface. C'est la déclaration d'un type générique. Par exemple:

public interface CallsForGrow {...}

public class GrowingArrayList <T implements CallsForGrow>  // BAD, won't work!
                              extends ArrayList<T> 

Ici, l'utilisation implementsest interdite syntaxiquement. J'ai d'abord pensé qu'il était interdit d'utiliser l'interface à l'intérieur de <>, mais non. C'est possible, je n'ai qu'à utiliser à la extendsplace de implements. En conséquence, je "prolonge" une interface. Cet autre exemple fonctionne:

public interface CallsForGrow {...}

public class GrowingArrayList <T extends CallsForGrow>  // this works!
                              extends ArrayList<T> 

Cela me semble être une incohérence syntaxique. Mais peut-être que je ne comprends pas certaines finesses de Java 6? Y a-t-il d'autres endroits où je devrais étendre les interfaces? L'interface, que je veux étendre, devrait-elle avoir des fonctionnalités spéciales?

Dans le cas des variables de type génériques, le compilateur ne se soucie pas réellement s'il Ts'agit d'une classe, d'une interface, d'une énumération ou d'une annotation. Tout ce qui compte c'est qu'il s'agit d'un type avec un ensemble donné de sous-et super-types.

Et il n'y a aucune raison de compliquer la syntaxe simplement parce qu'à un autre endroit (où vous implémentez réellement une interface) la distinction entre les classes et les interfaces est pertinente (par exemple, si vous êtes implementune interface, vous devez implémenter toutes les méthodes qu'elle définit, mais vous pas besoin, si vous êtes extendune classe (non abstraite)).

En supposant un instant que vous deviez écrire implementsici, vous auriez également besoin d'une syntaxe distincte pour les enumvaleurs (au lieu de simplement écrire <E extends Enum<E>>) et les annotations (que vous pouvez facilement déclarer en utilisant <A extends Annotation>).

Le seul endroit où vous devez écrire implementsest au point où vous implémentez réellement l'interface. À ce stade (et à ce stade uniquement), la différence est importante, car vous devez implémenter les méthodes définies dans l'interface. Pour tout le monde, peu importe si une donnée Aest une classe de base ou une interface implémentée de B: c'est un super-type et c'est tout ce qui compte.

Notez également qu'il existe un autre endroit où vous utilisez extendsdes interfaces:

interface A {
}

interface B extends A {
}

À ce stade, ce implementsserait faux, car B ne met pas en œuvre A .

Lorsque Java 5, et en particulier les génériques, a été initialement mis à la disposition des développeurs qui avaient manifesté un intérêt, la syntaxe était tout à fait différente. Au lieu de Set<? extends Foo>et Set<? super Bar>il y avait Set<+Foo>et Set<-Foo>. Cependant, la rétroaction était qu'il n'était pas clair si cela +signifiait plus spécifique ou plus large (plus de classes) . Sun a répondu à cette rétroaction en changeant la syntaxe, mais dans la contrainte de ne pas introduire de nouveaux mots clés, ce qui aurait posé un problème de compatibilité descendante.

Le résultat est que ni l'un ni l'autre n'est tout à fait naturel. Comme vous le constatez, extendsest surchargé pour parler de classes "étendant" les interfaces, ce qui n'est pas le langage utilisé dans d'autres contextes; et superest surchargé pour signifier "est une superclasse de", qui est la direction opposée de la relation précédemment exprimée par le mot-clé, c'est-à-dire se référant à une superclasse.

Cependant, les principes fondamentaux de ce qu'est une interface ne sont pas affectés par ce changement, et il n'introduit pas d'interfaces spéciales qui sont étendues d'une nouvelle manière.

Il y a des inconvénients à autoriser et à interdire une telle syntaxe, et ceux d' autoriser sont bien plus importants.

Pensez-y.

La séparation de l'interface et de l'implémentation est l'un des idiomes de programmation fondamentaux. Pour cette raison, la syntaxe permettant d'épeler "l'interface implémente quelque chose" serait à peu près aussi mauvaise que celle utilisant le signe plus pour désigner la multiplication des opérandes.

Il faut comprendre la programmation pilotée par interface comme prochaine étape tout en comprenant une interface. Il indique quelle est l'utilisation réelle de l'interface. Quel rôle il joue dans un programme Java (ou tout autre langage).