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:
Méthodes statiques d’ interface:
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:
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:
méthode par défaut dans l’interface:
Avantage: