Différence entre les méthodes statiques et par défaut dans l'interface
J'apprenais via des interfaces lorsque 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");
}
}
Nous vous saurions gré d'expliquer la différence des deux et aussi s'il y a un exemple de quand nous utiliserions ceci serait Nice. Un peu confus sur les interfaces.
Différences entre les méthodes statiques et les méthodes par défaut dans Java 8:
1) Les méthodes par défaut peuvent être sont écrasées dans la classe d'implémentation, alors que statique ne peut pas .
2) La méthode statique appartient à seulement à la classe d'interface. Vous ne pouvez donc invoquer une méthode statique que sur la classe d'interface et non 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(String[] args) {
MyClass.staticMethod(); //not valid - static method may be invoked on containing interface class only
MyInterface.staticMethod(); //valid
}
}
3) La classe et l'interface peuvent avoir méthodes statiques avec le même nom, et aucune autre n'est prioritaire!
public class MyClass implements MyInterface {
public static void main(String[] 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 à l'espace de noms de la classe, pour ainsi dire. Donc, une méthode staticfoo de l'interface Interface est accessible par Interface.foo(). Notez que l'appel de fonction ne s'applique à aucun instance particulier de l'interface.
Une implémentation par défaut, bar, 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 le peut.
1. expliquer la différence des deux
Les méthodes d'interface statiques sont similaires aux méthodes de classe statiques (ici, elles appartiennent à Interface uniquement). Où, comme méthodes d'interface par défaut, fournissent default implementation des méthodes d'interface (les classes d'implémentation peuvent override)
Mais rappelez-vous dans le cas où une classe est implementing more than one interface with same default signature de la méthode, puis la classe d'implémentation needs to override the default method
Vous trouverez un exemple simple ci-dessous (possibilité de bricolage dans différents cas)
public class Test {
public static void main(String[] 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(String name) {
System.out.println("Hello " + name);
}
}
class Test2 implements I1 {
@Override
public void test() {
System.out.println("testing 1234...");
}
@Override
public void hello(String name) {
System.out.println("bonjour" + name);
}
}
2. quand nous utiliserions ce serait Nice.
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 de votre spécification dans toutes les classes de ce contrat. Ou elle peut être utilisée comme Adapter classes.
voici une bonne lecture: https://softwareengineering.stackexchange.com/questions/233053/why-were-default-and-stat-methods-added-tourinterfaces-in-Java-8-when-we- déjà
le document Oracle décrit également les méthodes par défaut et statiques pour faire évoluer les interfaces existantes:
Utilisateurs ayant des classes qui implémentent des interfaces améliorées avec le nouveau Les méthodes par défaut ou statiques ne doivent pas être modifiées ni recompilées en accueillir 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 default et static ont permis de réduire les différences entre les classes interfaces et abstract.
Méthodes interface default:
- Cela permet d'éviter les classes utilitaires, telles que toutes les méthodes de la classe Collections peuvent être fournies dans les interfaces elles-mêmes.
- Cela aide à étendre les interfaces sans craindre de casser les classes d'implémentation.
Méthodes d'interface static:
- Ils font partie de l’interface, nous ne pouvons pas l’utiliser pour les objets de classe d’implémentation.
- Cela aide à assurer la sécurité en empêchant les classes d'implémentation de les remplacer.
Comme pour citer un autre utile référence .
Selon les Javadocs d'Oracle: http://docs.Oracle.com/javase/tutorial/Java/IandI/defaultmethods.html
Les méthodes par défaut vous permettent d'ajouter de nouvelles fonctionnalités aux interfaces de vos bibliothèques et d'assurer la compatibilité binaire avec le code écrit pour les versions antérieures de ces interfaces.
Une méthode statique est une méthode associée à la classe dans laquelle elle est définie plutôt qu'à un objet. 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 implémentant cette interface.
Exemple:
interface IDemo {
//this method can be called directly from anywhere this interface is visible
static int convertStrToInt(String numStr) {
return Integer.parseInt(numStr);
}
//getNum will be implemented in a class
int getNum();
default String numAsStr() {
//this.getNum will call the class's implementation
return Integer.toString(this.getNum());
}
}
Méthodes d'interface par défaut:
Cela permet d'éviter les classes utilitaires, telles que toutes les méthodes de la classe Collections peuvent être fournies dans les interfaces elles-mêmes.
Cela aide à étendre les interfaces sans craindre de casser les classes d'implémentation.
Méthodes d'interface statique:
Ils font partie de l’interface, nous ne pouvons pas l’utiliser pour les objets de classe d’implémentation.
Cela aide à assurer la sécurité en empêchant les classes d'implémentation de les remplacer.
Maintenant, comment méthode statique assurant 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(String str);
}
public class Example implements MyInterface {
// implementing abstract method
public void existingMethod(String str) {
System.out.println("String 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(String[] 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, la logique d'implémentation de la classe d'impression obj.newMethod(); signifie que nous pouvons modifier la logique de cette méthode dans la classe d'implémentation.
Cependant, la logique d'implémentation de la classe d'impression obj.anotherNewMethod(); n'a pas changé d'implémentation d'interface. Donc, si une logique de chiffrement-déchiffrement écrite à l'intérieur de cette méthode ne peut pas être modifiée.
Voici mon avis:
méthode statique dans l'interface:
Vous pouvez l'appeler directement (InterfacetA.staticMethod ())
La sous-classe ne pourra pas remplacer.
La sous-classe peut avoir une méthode portant le même nom que staticMethod
méthode par défaut in interface:
Vous ne pouvez pas l'appeler directement.
La sous-classe pourra le remplacer
Avantage:
Méthode static: Il n'est pas nécessaire de créer une classe séparée pour la méthode d'utilitaire.
default Méthode: Fournit la fonctionnalité commune de la méthode par défaut.
Le démarrage de l'interface Java 8 peut également avoir une méthode statique. Comme la méthode statique d'une classe, la méthode statique d'une interface peut être appelée à l'aide du nom d'interface.
Exemple
public interface Calculator {
int add(int a, int b);
int subtract(int a, int b);
default int multiply(int a, int b) {
throw new RuntimeException("Operation not supported. Upgrade to UltimateCalculator");
}
static void display(String value) {
System.out.println(value);
}
}
La différence entre la méthode d'interface statique et par défaut est que la méthode par défaut prend en charge l'héritage, contrairement à la méthode statique. La valeur par défaut peut être remplacée dans l'interface d'héritage.
Voici une bonne lecture sur la méthode d'interface par défaut et la méthode statique. Méthode d'interface par défaut dans Java 8
nous ne pouvons pas exécuter Interfacesample2.menthod3(); car ce n'est pas une méthode statique. Afin d'exécuter method3(), nous avons besoin d'une instance d'interface Interfacesample2.
Veuillez trouver l'exemple pratique suivant:
public class Java8Tester {
public static void main(String 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");
}
}