Memajukan Kaedah Lalai Secara Eksplisit dalam Java
Java 8 memperkenalkan kaedah lalai dalam antara muka, mendayakan sambungan antara muka tanpa mengubah suai pelaksanaan sedia ada. Walau bagaimanapun, persoalan timbul: bolehkah kita menggunakan pelaksanaan lalai kaedah secara eksplisit apabila ia telah ditindih atau konflik wujud disebabkan berbilang pelaksanaan lalai dalam antara muka yang berbeza?
Pertimbangkan contoh berikut:
interface A { default void foo() { System.out.println("A.foo"); } } class B implements A { @Override public void foo() { System.out.println("B.foo"); } public void afoo() { // How to invoke A.foo() here? } }
Untuk memanggil secara eksplisit pelaksanaan lalai A.foo() daripada afoo() dalam kelas B, kita boleh menggunakan sintaks:
A.super.foo();
Pendekatan ini membolehkan kami mengakses pelaksanaan lalai asal bagi kaedah walaupun apabila ia telah ditindih atau terdapat konflik dengan pelaksanaan lalai lain.
Dalam senario yang lebih kompleks , apabila berbilang antara muka mengandungi kaedah lalai dengan nama yang sama, kami boleh menggunakan sintaks yang sama untuk memilih pelaksanaan lalai khusus yang kami mahu gunakan:
public class ChildClass implements A, C { @Override public void foo() { // Override and do something else // Or manage conflicts A.super.foo(); C.super.foo(); // Default implementation from C } public void bah() { A.super.foo(); // Default implementation from A C.super.foo(); // Default implementation from C } }
Dengan menggunakan kaedah lalai secara eksplisit, kami boleh mengawal cara antara muka dilanjutkan, menyelesaikan konflik dan mengakses pelaksanaan asal seperti yang diperlukan, tanpa melanggar kontrak overriding. Ini memberikan fleksibiliti dan penyesuaian dalam reka bentuk berasaskan antara muka.
Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Memanggil Secara Eksplisit Kaedah Lalai Antara Muka Java Selepas Mengatasi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!