web-dev-qa-db-de.com

Unterschied zwischen statischen und Standardmethoden in der Schnittstelle

Ich habe durch Schnittstellen gelernt, als ich bemerkte, dass Sie jetzt statische und Standardmethoden in einer Schnittstelle definieren können. 

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

    public default void menthod3() {
        System.out.println("default print");
    }
}

Erklären Sie bitte den Unterschied zwischen den beiden und auch wenn es ein Beispiel gibt, wann wir dies verwenden würden, wäre Nizza. Ein wenig verwirrt über Interfaces.

76
Vipin Menon

Unterschiede zwischen statischen und Standardmethoden in Java 8:

1) Die Standardmethoden können in der implementierenden Klasse überschrieben werden, während statische nicht können.

2) Die statische Methode gehört zu only zur Interface-Klasse. Sie können also nur die statische Methode für die Interface-Klasse aufrufen, nicht für die Klasse, die dieses Interface implementiert, siehe:

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) Sowohl Klasse als auch Schnittstelle können statische Methoden mit demselben Namen haben und keine anderen überschreiben!

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..");
    }
}
81
stinger

Eine statische Methode ist eine Methode, die sich sozusagen auf die Klasse 'Namespace' bezieht. Auf eine static-Methode foo der Schnittstelle Interface wird von Interface.foo() zugegriffen. Beachten Sie, dass der Funktionsaufruf nicht für eine bestimmte Instanz der Schnittstelle gilt.

Eine Standardimplementierung bar wird dagegen von aufgerufen

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

Eine static-Schnittstellenmethode kann die Variable this nicht kennen, eine Standardimplementierung jedoch.

27
EyasSH

1. erkläre den Unterschied der beiden

Statische Schnittstellenmethoden sind wie statische Klassenmethoden (hier gehören sie nur zu Schnittstellen). Wo die voreingestellten Schnittstellenmethoden default implementation von Schnittstellenmethoden bereitstellen (welche implementierenden Klassen override sein können)
Aber denken Sie daran, falls eine Klasse eine implementing more than one interface with same default Methodensignatur ist, dann die implementierende Klasse needs to override the default method.

Unten finden Sie ein einfaches Beispiel (können Sie für verschiedene Fälle selbst basteln).

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. wenn wir dies verwenden würden, wäre Nizza.

Das hängt von Ihrer Problemstellung ab. Ich würde sagen, dass Standardmethoden nützlich sind, wenn Sie in allen Klassen in diesem Vertrag dieselbe Implementierung für eine Methode in Ihrer Spezifikation benötigen. Oder sie kann wie Adapter-Klassen verwendet werden.

hier ist eine gute Lektüre: https://softwareengineering.stackexchange.com/questions/233053/why-were-default-and-static-methods-added-to-interfaces-in-Java-8-when-we- alread

außerdem erklärt Oracle doc Standard- und statische Methoden für die Entwicklung vorhandener Schnittstellen:

Benutzer mit Klassen, die Schnittstellen implementieren, die mit neuem .__ erweitert wurden. Standard- oder statische Methoden müssen sie nicht in .__ ändern oder neu kompilieren. die zusätzlichen Methoden berücksichtigen.

http://docs.Oracle.com/javase/tutorial/Java/IandI/nogrow.html

13
Shail016

Dieser Link hat einige nützliche Erkenntnisse, einige davon haben wir hier aufgelistet.

Die Methoden default und static haben die Unterschiede zwischen den Klassen Interface und abstract reduziert.

Interface default Methoden:

  • Es hilft dabei, Dienstprogrammklassen zu vermeiden, beispielsweise kann die gesamte Klassenmethode Collections in den Schnittstellen selbst bereitgestellt werden.
  • Es hilft dabei, Schnittstellen zu erweitern, ohne Angst haben zu müssen, Implementierungsklassen zu brechen.

Methoden für Interface static:

  • Sie sind Teil der Schnittstelle und können nicht für Objekte der Implementierungsklasse verwendet werden.
  • Es hilft bei der Bereitstellung von Sicherheit, da Implementierungsklassen sie nicht überschreiben lassen.

Gerne ein weiteres nützliches reference .

8
Abhijeet

Laut Javadocs von Oracle: http://docs.Oracle.com/javase/tutorial/Java/IandI/defaultmethods.html

Mithilfe von Standardmethoden können Sie den Schnittstellen Ihrer Bibliotheken neue Funktionen hinzufügen und die binäre Kompatibilität mit Code sicherstellen, der für ältere Versionen dieser Schnittstellen geschrieben wurde.

Eine statische Methode ist eine Methode, die der Klasse zugeordnet ist, in der sie definiert ist, und nicht mit einem Objekt. Jede Instanz der Klasse teilt ihre statischen Methoden.

Normalerweise wird die statische Methode in der Schnittstelle als Hilfsmethode verwendet, während die Standardmethode als Standardimplementierung für Klassen verwendet wird, die diese Schnittstelle implementieren.

Beispiel:

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());
    }   

}
3
KennyC

Schnittstellen-Standardmethoden:

Es hilft dabei, Dienstprogrammklassen zu vermeiden, beispielsweise kann die gesamte Klassenmethode Collections in den Schnittstellen selbst bereitgestellt werden.

Es hilft dabei, Schnittstellen zu erweitern, ohne Angst haben zu müssen, Implementierungsklassen zu brechen.

Interface statische Methoden:

Sie sind Teil der Schnittstelle und können nicht für Objekte der Implementierungsklasse verwendet werden.

Es hilft bei der Bereitstellung von Sicherheit, da Implementierungsklassen sie nicht überschreiben lassen.

Nun, wie statische Methode Sicherheit bietet. Lassen Sie uns ein Beispiel sehen.

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");

    }
}

Hier bedeutet obj.newMethod(); Druckklassenimplementierungslogik, dass wir die Logik dieser Methode innerhalb der Implementierungsklasse ändern können.

Aber obj.anotherNewMethod(); druckt Klassenimplementierungslogik, aber nicht die Schnittstellenimplementierung. Wenn also eine Verschlüsselungs-Entschlüsselungslogik innerhalb dieser Methode geschrieben wird, können Sie nichts ändern.

3
Satish Keshri

Hier ist meine Ansicht:

statische Methode in Schnittstelle:

  • Sie können es direkt aufrufen (InterfacetA.staticMethod ())

  • Die Unterklasse kann nicht überschreiben.

  • Die Unterklasse kann eine Methode mit demselben Namen wie staticMethod haben

Standardmethode in Schnittstelle:

  • Sie können es nicht direkt anrufen.

  • Eine Unterklasse kann es überschreiben

Vorteil:

  • statische Methode: Sie müssen keine separate Klasse für die Utility-Methode erstellen.

  • Standardmethode: Bereitstellung der allgemeinen Funktionalität in der Standardmethode.

3
Vijay

Das Starten der Java 8-Schnittstelle kann auch eine statische Methode haben. Wie die statische Methode einer Klasse kann die statische Methode einer Schnittstelle über den Schnittstellennamen aufgerufen werden.

Beispiel

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);
    }
}

Der Unterschied zwischen der statischen und der Standardschnittstellenmethode besteht darin, dass die Standardmethode die Vererbung unterstützt, die statische Methode jedoch. Die Standardeinstellung kann beim Erben der Schnittstelle überschrieben werden.

Hier erfahren Sie mehr über die Standardmethode und die statische Methode der Benutzeroberfläche. Schnittstellenstandardmethode in Java 8

0

Interfacesample2.menthod3(); kann nicht ausgeführt werden, da dies keine statische Methode ist. Um method3() ausführen zu können, benötigen wir eine Instanz von Interfacesample2 interface. 

Hier finden Sie das folgende praktische Beispiel:

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");
    }
}
0
Premraj