Abstraksi: Antara Muka Penyahkodan dalam Java

Di Java, Antara Muka berfungsi sebagai kontrak yang mesti dipatuhi oleh kelas. Memandangkan antara muka hanya menyediakan pengetahuan tentang perkara yang boleh dilakukan (melalui tandatangan kaedah) dan menyembunyikan cara ia dilakukan (dengan menyerahkan pelaksanaan kepada kelas yang melaksanakan antara muka), ia mencapai abstraksi. Pemisahan apa daripada bagaimana ini merupakan idea teras di sebalik abstraksi.

Dengan Java 8, antara muka berkembang melangkaui tingkah laku abstrak semata-mata, menyokong kaedah lalai dan statik untuk meningkatkan fleksibiliti dan keserasian ke belakang.

Siaran ini menyelami antara muka, ciri utamanya dan perbezaan antara antara muka dan kelas abstrak, dengan contoh kod untuk membantu anda memahami konsep.

---

Apakah itu Antara Muka?

Antara muka dalam Java menentukan set tingkah laku (kaedah) yang mesti diikuti oleh kelas pelaksana. Ia hanya mengandungi tandatangan kaedah dan pemalar. Berbeza dengan kelas abstrak, antara muka membenarkan warisan berbilang dengan membolehkan kelas melaksanakan lebih daripada satu antara muka.

Ciri Utama Antara Muka:

• Pembolehubah dalam antara muka adalah terbuka secara tersirat, statik dan muktamad.

• Semua kaedah adalah terbuka dan abstrak secara tersirat (sebelum Java 8).

• Sebuah kelas boleh melaksanakan berbilang antara muka, mengatasi had warisan tunggal kelas.

• Dari Java 8 dan seterusnya, antara muka juga boleh mengandungi kaedah lalai dan statik, meningkatkan keserasian ke belakang.

---

Asas: Sintaks Antara Muka

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

Penjelasan Konsep Utama:

1. Pembolehubah dalam Antara Muka:

• awam: Boleh diakses oleh mana-mana kelas yang melaksanakan antara muka.
• statik: Boleh diakses terus menggunakan nama antara muka.
• muktamad: Menghalang pengubahsuaian nilai sebaik sahaja ia dimulakan untuk memastikan ketekalan.

Nota: pembolehubah akhir statik boleh dimulakan sama ada pada masa pengisytiharan atau dalam blok statik. Walau bagaimanapun, memandangkan antara muka tidak membenarkan blok statik, pembolehubah ini mesti dimulakan semasa pengisytiharan.

2. Kaedah Abstrak:

• Ini adalah tandatangan kaedah tanpa sebarang badan atau pelaksanaan.
• Mereka awam secara lalai dalam antara muka.
• Semua kaedah abstrak mesti ditindih oleh kelas pelaksana.

3. Kaedah Lalai:

• Diperkenalkan dalam Java 8 untuk menyediakan pelaksanaan lalai untuk kaedah dalam antara muka.
• Kaedah ini awam secara lalai.
• Melaksanakan kelas boleh mengatasinya, tetapi ia tidak wajib.
• Di sini, "Lalai" bukan pengubah suai akses; ia hanya menunjukkan bahawa kaedah itu bukan abstrak dan boleh mempunyai pelaksanaan yang konkrit.
• Ciri ini membantu pembangun melanjutkan antara muka sedia ada tanpa memecahkan keserasian ke belakang.

4. Kaedah Statik:

• Kaedah statik milik antara muka.
• Mereka hanya boleh diakses menggunakan nama antara muka.
• Kaedah ini awam secara lalai.
• Mereka tidak diwarisi dengan melaksanakan kelas.
• Kaedah statik tidak boleh ditindih.

---

Melaksanakan Antara Muka dalam Java

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

Penjelasan Konsep Utama:

1. Akses Kaedah:
   Kaedah lalai (concreteMethod()) dan kaedah overridden (abstractMethod()) diakses menggunakan obj instance kelas, menunjukkan cara kedua-dua jenis kaedah boleh dipanggil.

2. Mengakses Pembolehubah Antara Muka:
   Id pembolehubah antara muka boleh diakses menggunakan kedua-dua nama antara muka (InterfaceBasics.id) dan nama kelas pelaksana (InterfaceBasicsImpl.id). Ini menunjukkan bahawa pembolehubah akhir statik dalam antara muka diwarisi, membenarkan kelas pelaksana merujuk kepada pembolehubah.

3. Akses Kaedah Statik:
   Kaedah statik staticMethod() hanya boleh dipanggil menggunakan nama antara muka (InterfaceBasics.staticMethod()). Percubaan untuk mengaksesnya melalui kelas pelaksana (InterfaceBasicsImpl.staticMethod()) menghasilkan ralat masa kompilasi, kerana kaedah statik dalam antara muka tidak diwarisi.

---

Mengapa Kaedah Lalai dan Statik?

1. Kaedah Lalai

• Sebelum Java 8, menambah kaedah baharu pada antara muka menimbulkan cabaran yang ketara. Sebarang kefungsian baharu memerlukan semua kelas pelaksana dikemas kini, yang sering menyebabkan perubahan dalam pangkalan kod yang besar.

• Dengan pengenalan kaedah lalai, antara muka kini boleh menyediakan pelaksanaan konkrit untuk kaedah baharu, memastikan keserasian ke belakang. Ini bermakna kelas sedia ada boleh kekal tidak berubah sambil masih mendapat manfaat daripada ciri baharu.

• Pilihan reka bentuk ini juga membuka jalan untuk menambahkan fungsi strim dan lambdas pada Rangka Kerja Koleksi.

2. Kaedah Statik

• Kaedah statik menyediakan fungsi utiliti yang berkaitan dengan antara muka dan tidak perlu ditindih dengan melaksanakan kelas.

• Dengan mengikat kaedah statik pada antara muka itu sendiri dan menghalang pewarisan, Java mengelakkan potensi kekaburan dan kekeliruan yang mungkin timbul daripada perlanggaran nama kaedah merentas berbilang antara muka yang terkenal sebagai Masalah Berlian.

• Contoh Kes Penggunaan: Berikut ialah kes penggunaan dunia sebenar antara muka dengan kaedah statik untuk konfigurasi pengelogan:

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

• Dalam contoh ini, kaedah statik getDefaultLogFileName() menyediakan cara untuk mendapatkan semula nama fail log lalai sambil memastikan pelaksanaan bersih dan dikemas dalam antara muka.

---

Bagaimanakah Antara Muka Masih Berbeza daripada Kelas Abstrak?

Walaupun dengan kaedah lalai, antara muka tetap berbeza daripada kelas abstrak:

Aspect	Interface	Abstract Class
Methods	Can have abstract, default, and static methods	Can have abstract and non-abstract methods
Variables	Only public, static, and final variables	Can have any access modifier and instance variables
Inheritance	Supports multiple inheritance	Supports single inheritance
Constructors	Cannot have constructors	Can have constructors

Aspek Antaramuka Kelas Abstrak Kaedah Boleh mempunyai kaedah abstrak, lalai dan statik Boleh mempunyai kaedah abstrak dan bukan abstrak Pembolehubah Hanya pembolehubah awam, statik dan akhir Boleh mempunyai sebarang pengubah suai akses dan pembolehubah contoh Warisan Menyokong berbilang warisan Menyokong warisan tunggal Pembina Tidak boleh mempunyai pembina Boleh mempunyai pembina table>

Kaedah lalai harus digunakan hanya untuk melanjutkan antara muka sedia ada di mana keserasian ke belakang diperlukan. Mereka bukan pengganti untuk kelas abstrak.

---

Soalan Temuduga Biasa tentang Antara Muka

1. Bolehkah pembolehubah antara muka diubah suai?

Tidak, pembolehubah antara muka adalah muktamad secara tersirat, bermakna nilainya tidak boleh diubah setelah ditetapkan.

package oops.interfaces;

public interface InterfaceBasics {

    // Variables are public, static, and final by default
    // Initialization can only be done with declaration (No Static Blocks)
    // Compiler Interpretation: public static final int id = 90;
    int id = 90;

    // Abstract method (public and abstract by default)
    // Compiler Interpretation: public abstract void abstractMethod();
    void abstractMethod();

    // Default method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public default void concreteMethod()
    default void concreteMethod() {
        System.out.println("Concrete Method Called");
    }

    // Static method - Introduced in Java 8 (public by default)
    // Compiler Interpretation: public static void staticMethod()
    static void staticMethod() {
        System.out.println("Static Method Called");
    }
}

2. Bolehkah kami mengisytiharkan kaedah lalai dan statik?

Tidak. Satu kaedah lalai menyediakan pelaksanaan konkrit yang boleh ditindih dengan melaksanakan kelas, membenarkan fleksibiliti. Sebaliknya, kaedah statik kepunyaan antara muka itu sendiri, tidak boleh ditindih dan menawarkan fungsi utiliti. Oleh itu, kedua-dua tidak boleh digunakan bersama.

package oops.interfaces;

// A class implementing the InterfaceBasics interface
public class InterfaceBasicsImpl implements InterfaceBasics {

    // Mandatory: Override all abstract methods from the interface
    @Override
    public void abstractMethod() {
        System.out.println("Overridden Method Called");
    }

    public static void main(String[] args) {
        InterfaceBasics obj = new InterfaceBasicsImpl();

        // Calling interface's default and overridden methods
        obj.concreteMethod();  // Output: Default Method Called
        obj.abstractMethod();  // Output: Overridden Method Called

        // Accessing interface variables (static and final by default)
        // Interface variables are inherited
        // Possible with both interface name and implementing class name
        System.out.println(InterfaceBasics.id);        // Output: 90
        System.out.println(InterfaceBasicsImpl.id);    // Output: 90

        // Cannot assign a value to final variable 'id'
        InterfaceBasicsImpl.id = 100;  // --> Compile Error

        // Calling static method using interface name
        // Cannot access using implementing class name
        // Interface static methods are NOT inherited
        InterfaceBasics.staticMethod();  // Output: Static Method Called
    }
}

3. Mengapa Kaedah Statik dalam Antara Muka Tidak Boleh Diwarisi?

Kaedah statik dikaitkan dengan antara muka itu sendiri dan bukannya sebarang contoh kelas tertentu, bermakna ia tergolong dalam antara muka secara keseluruhan. Jika kaedah statik diwarisi dengan melaksanakan kelas, ia boleh menyebabkan kekaburan dan kekeliruan tentang kaedah yang dipanggil, terutamanya jika berbilang antara muka mentakrifkan kaedah dengan nama yang sama.

Contohnya:

package oops.interfaces.example;

public interface Logger {

    // Using a variable to store the default log file name
    String DEFAULT_LOG_FILE_NAME = "application.log";

    // Static method to get the default log file name with configuration
    static String getDefaultLogFileName() {
        // Simulating configuration retrieval
        // Could be from a properties file or environment variable
        String logFileName = System.getenv("LOG_FILE_NAME");

        // If a log file name is set in the environment, return it;
        // Otherwise, return the default
        if (logFileName != null && !logFileName.isEmpty()) {
            return logFileName;
        } else {
            return DEFAULT_LOG_FILE_NAME;
        }
    }
}

public class FileLogger implements Logger {

    public static void main(String[] args) {
        // Using the interface variable
        String defaultLogFile = Logger.DEFAULT_LOG_FILE_NAME;

        // Using the static method
        if ("FILE".equals(System.getenv("LOG_TYPE"))) {
            defaultLogFile = Logger.getDefaultLogFileName();
        }

        System.out.println("Log file used: " + defaultLogFile);
    }
}

Dengan mengekalkan kaedah statik terikat hanya pada antara muka, Java mengekalkan kejelasan dan mengelakkan kemungkinan konflik dalam penyelesaian kaedah yang membawa kepada Masalah Berlian Warisan Berbilang yang terkenal.

---

Kesimpulan

Antara muka dalam Java memainkan peranan penting dalam mencapai abstraksi dengan mentakrifkan tingkah laku yang mesti dipatuhi oleh pelaksana kelas. Dengan pengenalan kaedah lalai dan kaedah statik dalam Java 8, antara muka telah menjadi lebih berkuasa, membenarkan keserasian ke belakang dan menyediakan kaedah utiliti secara langsung dalam antara muka.

Walau bagaimanapun, antara muka bukan pengganti untuk kelas abstrak. Ia harus digunakan apabila anda perlu mentakrifkan kontrak untuk tingkah laku, terutamanya apabila warisan berbilang diperlukan.

---

Pengambilan Utama:

• Antaramuka menyediakan abstraksi dengan mentakrifkan perkara yang perlu dilakukan oleh kelas, tanpa menyatakan caranya.

• Pembolehubah dalam antara muka sentiasa awam, statik dan muktamad.

• Kaedah lalai dan statik, yang diperkenalkan dalam Java 8, membenarkan keserasian ke belakang dan pelaksanaan utiliti dalam antara muka.

• Kaedah statik dalam antara muka tidak diwarisi, memastikan kejelasan dalam penggunaannya.

Memahami cara dan masa untuk menggunakan antara muka bukan sahaja akan meningkatkan kemahiran pengekodan anda tetapi juga menyediakan anda untuk soalan temu bual sekitar konsep OOPs dan corak reka bentuk Java.

---

Catatan Berkaitan

• Asas Java

• Keperluan Temuduga Tatasusunan

• Java Memory Essentials

• Java Keywords Essentials

• Kerangka Kerja Koleksi Penting

Selamat Pengekodan!

Atas ialah kandungan terperinci Abstraksi: Antara Muka Penyahkodan dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!