Perbedaan Antara metode statis dan default dalam antarmuka

Saya belajar melalui antarmuka ketika saya perhatikan bahwa Anda sekarang dapat menentukan metode statis dan default dalam sebuah antarmuka.

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

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

Mohon jelaskan perbedaan keduanya dan juga jika ada contoh kapan kita akan menggunakan ini akan menyenangkan. Sedikit bingung tentang Antarmuka.

Perbedaan antara metode statis dan default di Java 8:

1) Metode default dapat diganti dalam kelas implementasi, sedangkan statis tidak bisa .

2) Metode statis hanya milik kelas Antarmuka, jadi Anda hanya dapat memanggil metode statis pada kelas Antarmuka, bukan pada kelas yang mengimplementasikan Antarmuka ini, lihat:

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) Baik kelas dan antarmuka dapat memiliki metode statis dengan nama yang sama, dan tidak ada yang menimpa yang lain!

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

Metode statis adalah metode yang berlaku untuk 'namespace' kelas, bisa dikatakan. Jadi staticmetode fooantarmuka Interfacediakses oleh Interface.foo(). Perhatikan bahwa panggilan fungsi tidak berlaku untuk contoh tertentu antarmuka tertentu.

Implementasi default bardi sisi lain, dipanggil oleh

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

Sebuah staticmetode antarmuka tidak dapat mengetahui tentang thisvariabel, tetapi implementasi default bisa.

1. Jelaskan perbedaan keduanya

Metode antarmuka statis seperti metode kelas statis (di sini metode tersebut hanya dimiliki oleh Antarmuka). Dimana sebagai metode antarmuka default menyediakan metode default implementationantarmuka (yang menerapkan kelas mungkin override)
Tapi ingat jika kelas adalah implementing more than one interface with same defaulttanda tangan metode maka kelas pelaksananeeds to override the default method

Anda dapat menemukan contoh sederhana di bawah ini (dapat DIY untuk berbagai kasus)

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. bila kita akan menggunakan ini alangkah baiknya.

Itu tergantung pada pernyataan masalah Anda. Saya akan mengatakan Metode default berguna, jika Anda memerlukan implementasi yang sama untuk metode dalam spesifikasi Anda di semua kelas dalam kontrak itu, Atau dapat digunakan sepertiAdapter kelas.

ini bacaan yang bagus: /software/233053/why-were-default-and-static-methods-added-to-interfaces-in-java-8-when-we-alread

juga di bawah oracle doc menjelaskan metode default & statis untuk mengembangkan antarmuka yang ada:

Pengguna yang memiliki kelas yang mengimplementasikan antarmuka yang ditingkatkan dengan metode default atau statis baru tidak perlu memodifikasi atau mengkompilasi ulang untuk mengakomodasi metode tambahan.

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

Inilah pandangan saya:

metode statis dalam antarmuka:

• Anda bisa memanggilnya secara langsung (InterfacetA.staticMethod ())

• Sub-kelas tidak akan dapat mengganti.

• Sub-kelas mungkin memiliki metode dengan nama yang sama dengan staticMethod

metode default di antarmuka:

• Anda tidak bisa memanggilnya secara langsung.

• Sub-kelas akan dapat menggantinya

Keuntungan:

• Metode statis: Anda tidak perlu membuat kelas terpisah untuk metode utilitas.

• Metode default: Menyediakan fungsionalitas umum dalam metode default.

Tautan ini memiliki beberapa wawasan yang berguna, beberapa di antaranya telah tercantum di sini.

metode default & statis telah menjembatani perbedaan antara antarmuka dan kelas abstrak .

Metode default antarmuka :

• Ini membantu dalam menghindari kelas utilitas, seperti semua metode kelas Koleksi dapat disediakan di antarmuka itu sendiri.
• Ini membantu dalam memperluas antarmuka tanpa takut melanggar kelas implementasi.

Antarmuka metode statis :

• Mereka adalah bagian dari antarmuka, kita tidak dapat menggunakannya untuk objek kelas implementasi.
• Ini membantu dalam memberikan keamanan dengan tidak mengizinkan kelas implementasi untuk menimpanya.

Suka mengutip referensi bermanfaat lainnya .

Metode default antarmuka:

Ini membantu dalam menghindari kelas utilitas, seperti semua metode kelas Koleksi dapat disediakan di antarmuka itu sendiri.

Ini membantu dalam memperluas antarmuka tanpa takut melanggar kelas implementasi.

Antarmuka metode statis:

Mereka adalah bagian dari antarmuka, kita tidak dapat menggunakannya untuk objek kelas implementasi.

Ini membantu dalam memberikan keamanan dengan tidak mengizinkan kelas implementasi untuk menimpanya.

Sekarang bagaimana metode statis memberikan keamanan. Mari kita lihat contohnya.

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

    }
}

Sini obj.newMethod(); mencetak logika implementasi kelas, berarti kita dapat mengubah logika metode itu di dalam kelas implementasi.

Tapi obj.anotherNewMethod();logika implementasi kelas pencetakan, tetapi tidak mengubah implementasi antarmuka. Jadi jika ada logika dekripsi enkripsi yang tertulis di dalam metode itu, Anda tidak dapat mengubahnya.

Menurut Oracle's Javadocs: http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

Metode default memungkinkan Anda menambahkan fungsionalitas baru ke antarmuka pustaka Anda dan memastikan kompatibilitas biner dengan kode yang ditulis untuk versi lama antarmuka tersebut.

Metode statis adalah metode yang dikaitkan dengan kelas tempat ia didefinisikan, bukan dengan objek apa pun. Setiap instance kelas berbagi metode statisnya.

Biasanya, metode statis dalam antarmuka digunakan sebagai metode Helper sedangkan metode default digunakan sebagai implementasi default untuk kelas yang mengimplementasikan antarmuka itu.

Contoh:

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

}

Sesuai dengan dokumen JLS Java14 :

Metode Default:

• Ini adalah metode instance yang dideklarasikan dalam antarmuka dengan pengubah default

• Itu hanya dapat diakses oleh instance kelas pelaksana saja

• Tubuhnya selalu diwakili oleh blok, yang menyediakan implementasi atau perilaku default untuk setiap kelas yang mengimplementasikan tanpa mengganti metode

• Itu tidak pernah bisa statis atau pribadi

Metode Statis:

• Itu bisa dipanggil oleh antarmuka tanpa referensi ke objek tertentu, seperti metode statis kelas

• Metode statis bisa menjadi pribadi

• Kelas pelaksana tidak dapat mengakses metode statis

Mari kita pahami dengan bantuan kode contoh di bawah ini:

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

kami tidak dapat mengeksekusi Interfacesample2.menthod3();karena ini bukan metode statis. Untuk mengeksekusi method3()kita membutuhkan sebuah instanceInterfacesample2 interface.

Silakan temukan contoh praktis berikut:

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

Memulai antarmuka Java 8 juga dapat memiliki metode statis. Seperti metode statis suatu kelas, metode statis suatu antarmuka dapat dipanggil menggunakan nama Antarmuka.

Contoh

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

Perbedaan antara metode antarmuka statis dan default adalah metode default mendukung pewarisan tetapi metode statis tidak. Metode default dapat diganti dalam antarmuka pewaris.

Berikut adalah bacaan yang bagus tentang metode default antarmuka dan metode statis. Metode Default Antarmuka di Java 8

Semua jawaban bagus di sini. Saya ingin menambahkan penggunaan praktis lain dari fungsi statis di antarmuka. Tip datang dari buku - Java Efektif, Edisi ke-3 oleh Joshua Bloch di Bab2: Membuat dan Menghancurkan Objek.

Static functions can be used for static factory methods. 

Metode pabrik statis adalah metode yang mengembalikan suatu objek. Mereka bekerja seperti konstruktor. Dalam kasus tertentu, metode pabrik statis menyediakan kode yang lebih mudah dibaca daripada menggunakan konstruktor.

Mengutip dari buku - Effective Java, Edisi ke-3 oleh Joshua Bloch

Sebelum Java 8, antarmuka tidak dapat memiliki metode statis. Menurut konvensi, metode pabrik statis untuk antarmuka bernama Type dimasukkan ke dalam kelas pendamping noninstantiable (Item 4) bernama Jenis.

Penulis memberikan contoh Koleksi di mana metode pabrik statis tersebut diterapkan. Memeriksa kodenya, Josh Bloch dapat dilihat sebagai penulis pertama kelas Koleksi. Meskipun Koleksi adalah kelas dan bukan antarmuka. Namun konsep tersebut tetap berlaku.

Misalnya, Java Collections Framework memiliki empat puluh lima implementasi utilitas dari antarmukanya, menyediakan koleksi yang tidak dapat dimodifikasi, koleksi yang disinkronkan, dan sejenisnya. Hampir semua implementasi ini diekspor melalui metode pabrik statis dalam satu kelas noninstantiable (java.util.Collections). Kelas dari objek yang dikembalikan semuanya nonpublik.

Lebih lanjut dia menjelaskan bahwa API tidak hanya lebih kecil, tetapi juga membantu keterbacaan kode dan kemudahan API ..

Bukan hanya sebagian besar API yang dikurangi tetapi bobot konseptualnya: jumlah dan tingkat kesulitan konsep yang harus dikuasai oleh pemrogram untuk menggunakan API. Pemrogram mengetahui bahwa objek yang dikembalikan memiliki API yang ditentukan dengan tepat oleh antarmukanya, jadi tidak perlu membaca dokumentasi kelas tambahan untuk kelas implementasi.

Berikut adalah salah satu metode statis dari kelas java.util.Collections:

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