Différence entre les méthodes statiques et par défaut dans l’interface

J’étais en train d’apprendre par les interfaces quand j’ai remarqué que vous pouvez maintenant définir des méthodes statiques et par défaut dans une interface.

public interface interfacesample2 { public static void method() { System.out.println("hello world"); } public default void menthod3() { System.out.println("default print"); } } 

Veuillez expliquer la différence entre les deux et s’il y a un exemple du moment où nous utiliserions cela serait bien. Un peu confus sur les interfaces.

Différences entre les méthodes statiques et par défaut dans Java 8:

1) Les méthodes par défaut peuvent être remplacées dans la classe d’implémentation, alors que les méthodes statiques ne le peuvent pas .

2) La méthode statique appartient uniquement à la classe Interface, vous ne pouvez donc invoquer que la méthode statique sur la classe Interface, pas sur la classe implémentant cette interface, voir:

 public interface MyInterface { default void defaultMethod(){ System.out.println("Default"); } static void staticMethod(){ System.out.println("Static"); } } public class MyClass implements MyInterface { public static void main(Ssortingng[] args) { MyClass.staticMethod(); //not valid - static method may be invoked on containing interface class only MyInterface.staticMethod(); //valid } } 

3) Les classes et les interfaces peuvent avoir des méthodes statiques avec les mêmes noms, et aucune ne remplace les autres!

 public class MyClass implements MyInterface { public static void main(Ssortingng[] args) { //both are valid and have different behaviour MyClass.staticMethod(); MyInterface.staticMethod(); } static void staticMethod(){ System.out.println("another static.."); } } 

Une méthode statique est une méthode qui s’applique à la classe «namespace», pour ainsi dire. Donc, une méthode static foo de l’interface Interface est accessible par Interface.foo() . Notez que l’appel de fonction ne s’applique à aucune instance particulière de l’interface.

Une bar implémentation par défaut est appelée par

 Interface x = new ConcreteClass(); x.bar(); 

Une méthode d’interface static ne peut pas connaître la variable this , mais une implémentation par défaut peut.

1. expliquer la différence des deux

Les méthodes d’interface statique sont comme les méthodes de classe statique (ici, elles appartiennent uniquement à l’interface). Où les méthodes d’interface par default implementation fournissent une default implementation des méthodes d’interface (que les classes d’implémentation peuvent override )
Mais rappelez-vous que si une classe implementing more than one interface with same default signature de méthode implementing more than one interface with same default , la classe d’implémentation needs to override the default method

Vous pouvez trouver un exemple simple ci-dessous (peut bricoler pour différents cas)

 public class Test { public static void main(Ssortingng[] args) { // Accessing the static member I1.hello(); // Anonymous class Not overriding the default method I1 t = new I1() { @Override public void test() { System.out.println("Anonymous test"); } }; t.test(); t.hello("uvw"); // Referring to class instance with overridden default method I1 t1 = new Test2(); t1.test(); t1.hello("xyz"); } } interface I1 { void test(); //static method static void hello() { System.out.println("hello from Interface I1"); } // default need not to be implemented by implementing class default void hello(Ssortingng name) { System.out.println("Hello " + name); } } class Test2 implements I1 { @Override public void test() { System.out.println("testing 1234..."); } @Override public void hello(Ssortingng name) { System.out.println("bonjour" + name); } } 

2. Quand nous utiliserions cela serait bien.

Cela dépend de votre énoncé de problème. Je dirais que les méthodes par défaut sont utiles si vous avez besoin de la même implémentation pour une méthode dans votre spécification dans toutes les classes de ce contrat, ou si elle est utilisée comme des classes d’ Adapter .

voici une bonne lecture: https://softwareengineering.stackexchange.com/questions/233053/why-default-and-static-methods-added-to-interfaces-in-java-8-when-we-alread

oracle doc explique également les méthodes par défaut et statiques pour l’évolution des interfaces existantes:

Les utilisateurs qui ont des classes qui implémentent des interfaces améliorées avec de nouvelles méthodes par défaut ou statiques ne doivent pas les modifier ou les recomstackr pour prendre en charge les méthodes supplémentaires.

http://docs.oracle.com/javase/tutorial/java/IandI/nogrow.html

Ce lien a quelques idées utiles, en ont énuméré quelques-unes ici.

Les méthodes par défaut et statiques ont permis de réduire les différences entre les interfaces et les classes abstraites .

Méthodes par défaut de l’ interface:

  • Cela aide à éviter les classes utilitaires, comme toutes les méthodes de classe Collections peuvent être fournies dans les interfaces elles-mêmes.
  • Il aide à étendre les interfaces sans craindre de casser les classes d’implémentation.

Méthodes statiques d’ interface:

  • Ils font partie de l’interface, nous ne pouvons pas l’utiliser pour les objects de classe d’implémentation.
  • Cela aide à assurer la sécurité en ne permettant pas aux classes d’implémentation de les remplacer.

Comme pour citer une autre référence utile.

Ceci est mieux expliqué dans la documentation Oracle .

Dans Java 8, les interfaces peuvent contenir des méthodes implémentées, des méthodes statiques et les méthodes dites “par défaut” (que les classes d’implémentation n’ont pas besoin de remplacer).

Dans ma vue (probablement naïve), il n’était pas nécessaire de violer les interfaces comme celle-ci. Les interfaces ont toujours été un contrat que vous devez remplir, et c’est un concept très simple et pur. Maintenant, c’est un mélange de plusieurs choses. À mon avis:

 static methods do not belong to interfaces. They belong to utility classes. "default" methods shouldn't have been allowed in interfaces at all. You could always use an abstract class for this purpose. 

En bref:

Avant Java 8

  • Vous pouvez utiliser des classes abstraites et régulières pour fournir des méthodes statiques et par défaut. Le rôle des interfaces est clair.
  • Toutes les méthodes d’une interface doivent être remplacées par des classes d’implémentation.
  • Vous ne pouvez pas append une nouvelle méthode dans une interface sans modifier toutes les implémentations, mais c’est en fait une bonne chose.

Après Java 8

  • Il n’y a pratiquement aucune différence entre une interface et une classe abstraite (autre qu’un inheritance multiple). En fait, vous pouvez émuler une classe régulière avec une interface.
  • Lors de la programmation des implémentations, les programmeurs peuvent oublier de remplacer les méthodes par défaut.
  • Il y a une erreur de compilation si une classe tente d’implémenter deux interfaces ou plus ayant une méthode par défaut avec la même signature.
  • En ajoutant une méthode par défaut à une interface, chaque classe d’implémentation hérite automatiquement de ce comportement. Certaines de ces classes n’ont peut-être pas été conçues pour cette nouvelle fonctionnalité, ce qui peut entraîner des problèmes. Par exemple, si quelqu’un ajoute une nouvelle méthode par défaut void foo () par défaut à une interface Ix, la classe Cx implémentant Ix et ayant une méthode foo privée avec la même signature ne comstack pas.

Selon Oracle Javadocs: http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

Les méthodes par défaut vous permettent d’append de nouvelles fonctionnalités aux interfaces de vos bibliothèques et d’assurer la compatibilité binary avec le code écrit pour les anciennes versions de ces interfaces.

Une méthode statique est une méthode associée à la classe dans laquelle elle est définie et non à un object. Chaque instance de la classe partage ses méthodes statiques.

Normalement, la méthode statique dans l’interface est utilisée comme méthode d’assistance tandis que la méthode par défaut est utilisée comme implémentation par défaut pour les classes qui implémentent cette interface.

Exemple:

 interface IDemo { //this method can be called directly from anywhere this interface is visible static int convertStrToInt(Ssortingng numStr) { return Integer.parseInt(numStr); } //getNum will be implemented in a class int getNum(); default Ssortingng numAsStr() { //this.getNum will call the class's implementation return Integer.toSsortingng(this.getNum()); } } 

Méthodes par défaut de l’interface:

Cela aide à éviter les classes utilitaires, comme toutes les méthodes de classe Collections peuvent être fournies dans les interfaces elles-mêmes.

Il aide à étendre les interfaces sans craindre de casser les classes d’implémentation.

Méthodes statiques d’interface:

Ils font partie de l’interface, nous ne pouvons pas l’utiliser pour les objects de classe d’implémentation.

Cela aide à assurer la sécurité en ne permettant pas aux classes d’implémentation de les remplacer.

Maintenant, comment la méthode statique fournissant la sécurité. Voyons un exemple.

 interface MyInterface { /* * This is a default method so we need not to implement this method in the implementation classes */ default void newMethod() { System.out.println("Newly added default method in Interface"); } /* * This is a static method. Static method in interface is similar to default method except that we cannot override them in the implementation classes. Similar to default methods, we need to implement these methods in implementation classes so we can safely add them to the existing interfaces. */ static void anotherNewMethod() { System.out.println("Newly added static method in Interface"); } /* * Already existing public and abstract method We must need to implement this method in implementation classes. */ void existingMethod(Ssortingng str); } public class Example implements MyInterface { // implementing abstract method public void existingMethod(Ssortingng str) { System.out.println("Ssortingng is: " + str); } public void newMethod() { System.out.println("Newly added default method in Class"); } static void anotherNewMethod() { System.out.println("Newly added static method in Class"); } public static void main(Ssortingng[] args) { Example obj = new Example(); // calling the default method of class obj.newMethod(); // calling the static method of class obj.anotherNewMethod(); // calling the static method of interface MyInterface.anotherNewMethod(); // calling the abstract method of interface obj.existingMethod("Java 8 is easy to learn"); } } 

Ici obj.newMethod(); La logique d’implémentation de la classe d’impression signifie que nous pouvons changer la logique de cette méthode dans la classe d’implémentation.

Mais obj.anotherNewMethod(); logique d’implémentation de classe d’impression, mais pas de modification de l’implémentation de l’interface. Donc, si aucune logique de chiffrement-déchiffrement écrite dans cette méthode ne peut être modifiée.

nous ne pouvons pas exécuter Interfacesample2.menthod3(); parce que ce n’est pas une méthode statique. Pour exécuter method3() nous avons besoin d’une instance de l’ Interfacesample2 Interfacesample2.

Veuillez trouver l’exemple pratique suivant:

 public class Java8Tester { public static void main(Ssortingng args[]){ // Interfacesample2.menthod3(); Cannot make a static reference to the non-static method menthod3 from the type Interfacesample2 new Interfacesample2(){ }.menthod3();// so in order to call default method we need an instance of interface Interfacesample2.method(); // it } } interface Interfacesample2 { public static void method() { System.out.println("hello world"); } public default void menthod3() { System.out.println("default print"); } } 

Voici ma vue:

méthode statique en interface:

  • Vous pouvez l’appeler directement (InterfacetA.staticMethod ())
  • La sous-classe ne pourra pas remplacer.
  • La sous-classe peut avoir une méthode avec le même nom que staticMethod

méthode par défaut dans l’interface:

  • Vous ne pouvez pas l’appeler directement.
  • La sous-classe pourra la remplacer

Avantage:

  • static Méthode: Vous n’avez pas besoin de créer une classe distincte pour la méthode utilitaire.
  • Méthode par défaut: Fournit la fonctionnalité commune dans la méthode par défaut.