Histoire de l'évolution des interfaces en Java

L'interface en Java a beaucoup évolué au fil des ans. Voyons quels changements se sont produits au cours de son développement.

Interfaces originales

Les interfaces de Java 1.0 étaient assez simples par rapport à ce qu'elles sont maintenant. Ils ne peuvent contenir que deux types d'éléments: les constantes et les méthodes abstraites publiques.

Champs constants

Les interfaces peuvent contenir des champs, tout comme les classes ordinaires, mais avec quelques différences:

• Les champs doivent être initialisés.
• Les champs sont considérés comme une finale publique statique
• Les modificateurs public, static et final n'ont pas besoin d'être spécifiés explicitement (ils sont déposés par défaut)

public interface MyInterface { int MY_CONSTANT = 9; } 

Même si cela n'est pas spécifié explicitement, le champ MY_CONSTANT est considéré comme une constante finale statique publique. Vous pouvez ajouter ces modificateurs, mais ce n'est pas nécessaire.

Méthodes abstraites

Les éléments les plus importants d'une interface sont ses méthodes. Les méthodes d'interface diffèrent également des méthodes de classe normales:

• Les méthodes n'ont pas de corps
• L'implémentation de la méthode est fournie par les classes qui implémentent cette interface.
• Les méthodes sont considérées comme publiques et abstraites même si elles ne sont pas explicitement spécifiées.
• Les méthodes ne peuvent pas être finales, car la combinaison de modificateurs abstraits et finaux n'est pas autorisée en Java

 public interface MyInterface { int doSomething(); String doSomethingCompletelyDifferent(); } 

Imbrication

Java 1.1 a introduit le concept de classes qui peuvent être placées dans d'autres classes. Ces classes sont de deux types: statiques et non statiques. Les interfaces peuvent également contenir d'autres interfaces et classes.

Même si cela n'est pas spécifié explicitement, ces interfaces et classes sont considérées comme publiques et statiques.

 public interface MyInterface { class MyClass { //... } interface MyOtherInterface { //... } } 

Énumérations et annotations

Deux autres types ont été introduits dans Java 5: les énumérations et les annotations. Ils peuvent également être placés à l'intérieur des interfaces.

 public interface MyInterface { enum MyEnum { FOO, BAR; } @interface MyAnnotation { //... } } 

Types génériques

Java 5 a introduit le concept des génériques, des types génériques. En bref: les génériques vous permettent d'utiliser un type générique au lieu de spécifier un type spécifique. Ainsi, vous pouvez écrire du code qui fonctionne avec un nombre différent de types sans sacrifier la sécurité et sans fournir une implémentation distincte pour chaque type.

Dans les interfaces commençant par Java 5, vous pouvez définir un type générique, puis l'utiliser comme type de valeur de retour d'une méthode ou comme type d'argument d'une méthode.

L'interface Box fonctionne que vous l'utilisiez pour stocker des objets tels que String, Integer, List, Shoe ou tout autre.

 interface Box<T> { void insert(T item); } class ShoeBox implements Box<Shoe> { public void insert(Shoe item) { //... } } 

Méthodes statiques

À partir de Java 8, vous pouvez inclure des méthodes statiques dans les interfaces. Cette approche a changé le fonctionnement de l'interface pour nous. Ils fonctionnent maintenant très différemment de la façon dont ils fonctionnaient avant Java 8. Initialement, toutes les méthodes des interfaces étaient abstraites. Cela signifiait que l'interface ne fournissait qu'une signature, mais pas une implémentation. L'implémentation a été laissée aux classes implémentant votre interface.

Lorsque vous utilisez des méthodes statiques dans les interfaces, vous devez également fournir une implémentation du corps de la méthode. Pour utiliser cette méthode dans une interface, utilisez simplement le mot-clé statique. Les méthodes statiques sont considérées comme publiques par défaut.

 public interface MyInterface { // This works static int foo() { return 0; } // This does not work, // static methods in interfaces need body static int bar(); } 

Héritage de méthode statique

Contrairement aux méthodes statiques classiques, les méthodes statiques dans les interfaces ne sont pas héritées. Cela signifie que si vous souhaitez appeler une telle méthode, vous devez l'appeler directement à partir de l'interface, et non à partir de la classe qui l'implémente.

 MyInterface.staticMethod(); 

Ce comportement est très utile pour éviter plusieurs problèmes d'héritage. Imaginez que vous ayez une classe qui implémente deux interfaces. Chacune des interfaces a une méthode statique avec le même nom et la même signature. Lequel doit être utilisé en premier?

Pourquoi est-ce utile

Imaginez que vous ayez une interface et un ensemble complet de méthodes d'assistance qui fonctionnent avec les classes qui implémentent cette interface.

Traditionnellement, il y a eu une approche pour utiliser une classe d'accompagnement. En plus de l'interface, une classe utilitaire a été créée avec un nom très similaire contenant des méthodes statiques appartenant à l'interface.

Vous pouvez trouver des exemples d'utilisation de cette approche directement dans le JDK: l'interface java.util.Collection et la classe utilitaire java.util.Collections qui l'accompagnent.

Avec des méthodes statiques dans les interfaces, cette approche n'est plus pertinente, n'est pas nécessaire et n'est pas recommandée. Maintenant, vous pouvez tout avoir en un seul endroit.

Méthodes par défaut

Les méthodes par défaut sont similaires aux méthodes statiques dans la mesure où vous devez également leur fournir un corps. Pour déclarer une méthode par défaut, utilisez simplement le mot clé par défaut.

 public interface MyInterface { default int doSomething() { return 0; } } 

Contrairement aux méthodes statiques, les méthodes sont héritées par défaut des classes qui implémentent l'interface. Ce qui est important, ces classes peuvent redéfinir leur comportement si nécessaire.

Bien qu'il y ait une exception. L'interface ne peut pas avoir de méthodes par défaut avec la même signature que les méthodes toString, equals et hashCode de la classe Object. Jetez un œil à la réponse de Brian Goetz pour comprendre la validité d'une telle solution: Autorisez les méthodes par défaut à remplacer les méthodes d'Object.

Pourquoi est-ce utile

L'idée d'implémenter des méthodes directement dans l'interface ne semble pas tout à fait correcte. Alors pourquoi cette fonctionnalité a-t-elle été introduite pour la première fois?

Les interfaces ont un problème. Dès que vous donnez votre API à d'autres personnes, elle «pétrifiera» pour toujours (elle ne peut pas être modifiée sans douleur).

Par tradition, Java prend la compatibilité descendante très au sérieux. Les méthodes par défaut permettent d'étendre les interfaces existantes avec de nouvelles méthodes. Plus important encore, les méthodes par défaut fournissent déjà une implémentation spécifique. Cela signifie que les classes implémentant votre interface n'ont pas besoin d'implémenter de nouvelles méthodes. Mais, si nécessaire, les méthodes par défaut peuvent être remplacées à tout moment si leur implémentation cesse de convenir. Donc, en bref, vous pouvez fournir de nouvelles fonctionnalités aux classes existantes qui implémentent votre interface, tout en conservant la compatibilité.

Conflits

Imaginons que nous ayons une classe qui implémente deux interfaces. Ces interfaces ont une méthode par défaut avec le même nom et la même signature.

 interface A { default int doSomething() { return 0; } } interface B { default int doSomething() { return 42; } } class MyClass implements A, B { } 

Désormais, la même méthode par défaut avec la même signature est héritée de deux interfaces différentes. Chaque interface a sa propre implémentation de cette méthode.

Alors, comment notre classe sait-elle laquelle des deux implémentations différentes utiliser?

Il ne le saura pas. Le code ci-dessus entraînera une erreur de compilation. Si vous devez le faire fonctionner, vous devez remplacer la méthode conflictuelle dans votre classe.

 interface A { default int doSomething() { return 0; } } interface B { default int doSomething() { return 42; } } class MyClass implements A, B { // Without this the compilation fails @Override public int doSomething() { return 256; } } 

Méthodes privées

Avec l'avènement de Java 8 et l'introduction des méthodes par défaut et des méthodes statiques, les interfaces ont désormais la capacité de contenir non seulement les signatures de méthode, mais aussi leur implémentation. Lors de l'écriture de telles implémentations, il est recommandé de diviser les méthodes complexes en méthodes plus simples. Ce code est plus facile à réutiliser, à maintenir et à comprendre.

À cette fin, vous utiliseriez des méthodes privées, car elles peuvent contenir tous les détails d'implémentation qui ne devraient pas être visibles et utilisés de l'extérieur.

Malheureusement en Java 8, une interface ne peut pas contenir de méthodes privées. Cela signifie que vous pouvez utiliser:

1. Techniques corporelles longues, complexes et difficiles à comprendre.
2. Méthodes d'assistance faisant partie de l'interface. Cela viole le principe d'encapsulation et pollue l'API publique de l'interface et des classes d'implémentation.

Heureusement, à partir de Java 9, vous pouvez utiliser des méthodes privées dans les interfaces . Ils ont les caractéristiques suivantes:

• les méthodes privées ont un corps, elles ne sont pas abstraites
• ils peuvent être statiques ou non statiques
• ils ne sont pas hérités par les classes qui implémentent l'interface et les interfaces
• ils peuvent appeler d'autres méthodes d'interface
• les méthodes privées peuvent appeler d'autres méthodes privées, abstraites, statiques ou par défaut
• les méthodes statiques privées ne peuvent appeler que d'autres méthodes statiques statiques et privées

 public interface MyInterface { private static int staticMethod() { return 42; } private int nonStaticMethod() { return 0; } } 

Ordre chronologique

Voici une liste chronologique des modifications par version de Java:

Java 1.1

Classes imbriquées

Interfaces imbriquées

Java 5

Types génériques

Transferts fermés

Annotations imbriquées

Java 8

Méthodes par défaut

Méthodes statiques

Java 9

Méthodes privées