Unterschied zwischen statischen und Standardmethoden in der Schnittstelle

Ich habe über 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 dafür gibt, wann wir dies verwenden würden, wäre es schön. Ein wenig verwirrt über Schnittstellen.

Unterschiede zwischen statischen und Standardmethoden in Java 8:

1) Standardmethoden können beim Implementieren von Klassen überschrieben werden, statische nicht .

2) Die statische Methode gehört nur zur Interface-Klasse. Sie können also nur die statische Methode für die Interface-Klasse aufrufen, nicht für die Klasse, die diese Schnittstelle 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 überschreibt andere!

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

Eine statische Methode ist eine Methode, die sozusagen auf den Klassennamensraum angewendet wird. So ein staticVerfahren fooder Schnittstelle Interfacezugegriffen durch Interface.foo(). Beachten Sie, dass der Funktionsaufruf nicht für eine bestimmte Instanz der Schnittstelle gilt.

Eine Standardimplementierung wird bardagegen von aufgerufen

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

Eine staticSchnittstellenmethode kann die thisVariable nicht kennen , eine Standardimplementierung jedoch.

1. Erklären Sie den Unterschied zwischen den beiden

Statische Schnittstellenmethoden sind wie statische Klassenmethoden (hier gehören sie nur zur Schnittstelle). Wobei als Standardschnittstellenmethoden Schnittstellenmethoden default implementationbereitgestellt werden (welche implementierenden Klassen möglicherweise override).
Denken Sie jedoch daran, falls dies eine Klasse istimplementing more than one interface with same default implementierende Klasse Methodensignatur handeltneeds to override the default method

Unten finden Sie ein einfaches Beispiel (kann DIY für verschiedene Fälle)

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. wann wir das benutzen würden wäre schön.

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

Hier ist eine gute Lektüre: /software/233053/why-were-default-and-static-methods-added-to-interfaces-in-java-8-when-we-alread

Ebenfalls unten erläutert Oracle Doc Standard- und statische Methoden zum Entwickeln vorhandener Schnittstellen:

Benutzer mit Klassen, die Schnittstellen implementieren, die mit neuen Standard- oder statischen Methoden erweitert wurden, müssen diese nicht ändern oder neu kompilieren, um die zusätzlichen Methoden zu berücksichtigen.

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

Hier ist meine Ansicht:

statische Methode in der Schnittstelle:

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

• Die Unterklasse kann nicht überschrieben werden.

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

Standardmethode in der Schnittstelle:

• Sie können es nicht direkt aufrufen.

• Die Unterklasse kann sie überschreiben

Vorteil:

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

• Standardmethode: Stellen Sie die allgemeine Funktionalität der Standardmethode bereit.

Dieser Link enthält einige nützliche Erkenntnisse, von denen einige hier aufgelistet sind.

Standard- und statische Methoden haben die Unterschiede zwischen Schnittstellen und abstrakten Klassen überbrückt .

Standardmethoden der Schnittstelle :

• Es hilft dabei, Dienstprogrammklassen zu vermeiden, da alle Collections-Klassenmethoden in den Schnittstellen selbst bereitgestellt werden können.
• Es hilft beim Erweitern von Schnittstellen, ohne die Angst zu haben, Implementierungsklassen zu brechen.

Statische Methoden der Schnittstelle :

• Sie sind Teil der Schnittstelle. Wir können sie nicht für Implementierungsklassenobjekte verwenden.
• Es hilft bei der Bereitstellung von Sicherheit, indem es Implementierungsklassen nicht erlaubt, sie zu überschreiben.

Zitieren Sie gerne eine weitere nützliche Referenz .

Standardmethoden der Schnittstelle:

Es hilft dabei, Dienstprogrammklassen zu vermeiden, da alle Collections-Klassenmethoden in den Schnittstellen selbst bereitgestellt werden können.

Es hilft beim Erweitern von Schnittstellen, ohne die Angst zu haben, Implementierungsklassen zu brechen.

Statische Methoden der Schnittstelle:

Sie sind Teil der Schnittstelle. Wir können sie nicht für Implementierungsklassenobjekte verwenden.

Es hilft bei der Bereitstellung von Sicherheit, indem es Implementierungsklassen nicht erlaubt, sie zu überschreiben.

Nun, wie statische Methode Sicherheit bietet. Sehen wir uns ein Beispiel an.

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 das obj.newMethod();Drucken der Klassenimplementierungslogik, dass wir die Logik dieser Methode innerhalb der Implementierungsklasse ändern können.

Aber obj.anotherNewMethod();Druckklassen-Implementierungslogik, aber nicht geänderte Schnittstellenimplementierung. Wenn also eine Verschlüsselungs- / Entschlüsselungslogik in diese Methode geschrieben ist, können Sie diese nicht ändern.

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

Mit Standardmethoden können Sie den Schnittstellen Ihrer Bibliotheken neue Funktionen hinzufügen und die Binärkompatibilitä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 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());
    }   

}

Per Java14 JLS doc:

Standardmethode:

• Es ist eine Instanzmethode, die in einer Schnittstelle mit dem Standardmodifikator deklariert ist

• Auf sie kann nur von der Instanz der implementierenden Klasse zugegriffen werden

• Sein Hauptteil wird immer durch einen Block dargestellt, der eine Standardimplementierung oder ein Standardverhalten für jede implementierende Klasse bereitstellt, ohne die Methode zu überschreiben

• Es kann niemals statisch oder privat sein

Statische Methode:

• Es kann von der Schnittstelle ohne Verweis auf ein bestimmtes Objekt aufgerufen werden, genau wie Klassenstatikmethoden

• Die statische Methode kann privat sein

• Die implementierende Klasse kann nicht auf statische Methoden zugreifen

Verstehen wir es mit Hilfe des folgenden Beispielcodes:

            public interface MyInterface {
        
            private void privateMethod() {
                System.out.println("Hi, this is privateMethod");
            }
        
            private static void staticPrivateMethod() {
                System.out.println("Hi, this is staticPrivateMethod");
            }
        
            static void staticMethod() {
                //privateMethod();    // Non-static method cannot be referenced from a static contex
                System.out.println("Hi, this is staticMethod");
                staticPrivateMethod();
            }
        
            default void defaultMethod() {
                System.out.println("Hi, this is defaultMethod");
            }
        
        }
    
    public class MyInterfaceImpl implements MyInterface{
        public static void main(String[] args) {
    
            MyInterface.staticMethod();
            // myInterface.staticMethod(); // Not allowed
    
            MyInterface myInterface = new MyInterfaceImpl();
            myInterface.defaultMethod();
            // MyInterface.defaultMethod(); // Not allowed
    
        }
    }

Wir können nicht ausführen, Interfacesample2.menthod3();da es sich nicht um eine statische Methode handelt. Zur Ausführung method3()benötigen wir eine Instanz der Interfacesample2Schnittstelle.

Hier finden Sie folgendes praktisches 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");
    }
}

Das Starten der Java 8-Schnittstelle kann auch eine statische Methode haben. Wie die statische Methode einer Klasse kann die statische Methode einer Schnittstelle unter Verwendung des Schnittstellennamens 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 Standardmethode der Schnittstelle besteht darin, dass die Standardmethode die Vererbung unterstützt, die statische Methode jedoch nicht. Die Standardmethode kann beim Erben der Schnittstelle überschrieben werden.

Hier finden Sie Informationen zur Standardmethode der Schnittstelle und zur statischen Methode. Standardmethode der Schnittstelle in Java 8

Alle guten Antworten hier. Ich möchte eine weitere praktische Verwendung der statischen Funktion in der Schnittstelle hinzufügen. Der Tipp stammt aus dem Buch - Effective Java, 3. Auflage von Joshua Bloch in Kapitel 2: Erstellen und Zerstören von Objekten.

Static functions can be used for static factory methods. 

Statische Factory-Methoden sind Methoden, die ein Objekt zurückgeben. Sie arbeiten wie Konstrukteure. In bestimmten Fällen bietet die statische Factory-Methode besser lesbaren Code als die Verwendung des Konstruktors.

Zitat aus dem Buch - Effective Java, 3. Auflage von Joshua Bloch

Vor Java 8 konnten Schnittstellen keine statischen Methoden haben. Konventionell wurden statische Factory-Methoden für eine Schnittstelle mit dem Namen Type in eine nicht instabilisierbare Begleitklasse (Element 4) mit dem Namen Types gestellt.

Der Autor gibt ein Beispiel für Sammlungen, in denen eine solche statische Factory-Methode implementiert ist. Josh Bloch, der den Code überprüft, kann als Erstautor der Collections-Klasse angesehen werden. Obwohl Sammlungen eine Klasse und keine Schnittstelle ist. Das Konzept gilt jedoch weiterhin.

Beispielsweise verfügt das Java Collections Framework über 45 Dienstprogrammimplementierungen seiner Schnittstellen, die nicht modifizierbare Sammlungen, synchronisierte Sammlungen und dergleichen bereitstellen. Fast alle dieser Implementierungen werden über statische Factory-Methoden in einer nicht instabilisierbaren Klasse (java.util.Collections) exportiert. Die Klassen der zurückgegebenen Objekte sind alle nicht öffentlich.

Weiter erklärt er, dass API nicht nur kleiner ist, sondern auch die Lesbarkeit des Codes und die API erleichtert.

Es wird nicht nur der Großteil der API reduziert, sondern auch das konzeptionelle Gewicht: die Anzahl und Schwierigkeit der Konzepte, die Programmierer beherrschen müssen, um die API verwenden zu können. Der Programmierer weiß, dass das zurückgegebene Objekt genau die von seiner Schnittstelle angegebene API hat, sodass keine zusätzliche Klassendokumentation für die Implementierungsklasse gelesen werden muss.

Hier ist eine der statischen Methoden aus der Klasse java.util.Collections:

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
    return new UnmodifiableCollection<>(c);
}