Antara Muka dan Kelas Abstrak di Jawa

Antara muka dan kelas abstrak ialah komponen penting untuk mencapai abstraksi dan polimorfisme.

Apakah Antara Muka?

Antara muka dalam Java ialah jenis rujukan, serupa dengan kelas, yang boleh mengandungi hanya kaedah abstrak, kaedah statik, kaedah lalai dan pembolehubah akhir statik (pemalar). Antara muka digunakan untuk mencapai abstraksi dan warisan berbilang dalam Java. Antara muka mungkin tidak boleh dibuat secara langsung.

?Sebelum Java 8, antara muka hanya boleh mempunyai kaedah abstrak.
Pelaksanaan kaedah ini perlu disediakan dalam kelas yang berasingan. Jadi, jika kaedah baharu hendak ditambah dalam antara muka, maka kod pelaksanaannya perlu disediakan dalam kelas yang melaksanakan antara muka yang sama.

?Untuk mengatasi isu ini, Java 8 telah memperkenalkan konsep kaedah lalai yang membolehkan antara muka mempunyai kaedah dengan pelaksanaan tanpa menjejaskan kelas yang melaksanakan antara muka .

Kaedah lalai boleh ditindih dengan melaksanakan kelas jika perlu.

Ciri-ciri Utama Antara Muka

• Kaedah Abstrak: Kaedah tanpa badan, diisytiharkan menggunakan kata kunci abstrak.
• Kaedah Lalai: Kaedah dengan badan, diperkenalkan dalam Java 8, membenarkan antara muka menyediakan pelaksanaan lalai.
• Kaedah Statik: Kaedah yang dimiliki oleh antara muka itu sendiri, bukan untuk kejadian antara muka.
• Pemalar: Pembolehubah diisytiharkan sebagai statik dan muktamad, yang secara tersirat terbuka.

Apakah Kelas Abstrak?

Kelas abstrak dalam Java ialah kelas yang tidak boleh dibuat instantiat sendiri dan mungkin mengandungi kaedah abstrak (kaedah tanpa badan) dan kaedah konkrit (kaedah dengan badan). Kelas abstrak digunakan untuk menyediakan asas yang sama untuk subkelas, membenarkan penggunaan semula kod dan takrifan tingkah laku yang dikongsi.

Ciri Utama Kelas Abstrak

• Kaedah Abstrak: Kaedah tanpa badan, diisytiharkan menggunakan kata kunci abstrak.
• Kaedah Konkrit: Kaedah dengan badan, menyediakan pelaksanaan lalai.
• Pembina: Kelas abstrak boleh mempunyai pembina, tetapi mereka tidak boleh dibuat secara langsung.
• Pembolehubah Instance: Kelas abstrak boleh mempunyai pembolehubah contoh dan pembolehubah statik.

Perbezaan Antara Antara Muka dan Kelas Abstrak

Pusaka Berbilang

• Antaramuka: Java menyokong berbilang warisan melalui antara muka, membenarkan kelas melaksanakan berbilang antara muka.
• Kelas Abstrak: Java tidak menyokong pewarisan berbilang kelas, bermakna kelas boleh melanjutkan hanya satu kelas abstrak.

Badan Kaedah

• Antaramuka: Sebelum Java 8, antara muka tidak boleh mengandungi badan kaedah. Dengan Java 8, kaedah lalai dan statik boleh mempunyai badan.
• Kelas Abstrak: Kelas abstrak boleh mengandungi kedua-dua kaedah abstrak (tanpa badan) dan kaedah konkrit (dengan badan).

Pembolehubah

• Antaramuka: Pembolehubah dalam antara muka adalah terbuka secara tersirat, statik dan muktamad.
• Kelas Abstrak: Kelas abstrak boleh mempunyai pembolehubah contoh, pembolehubah statik dan pemalar.

Penggunaan

• Antaramuka: Sesuai untuk menentukan kontrak yang boleh dilaksanakan oleh pelbagai kelas.
• Kelas Abstrak: Sesuai untuk menyediakan pangkalan yang sama untuk keluarga kelas yang berkaitan, berkongsi kod dan tingkah laku.

Pendekatan Java untuk Warisan

Java hanya menyokong warisan tunggal, bermakna setiap kelas boleh mewarisi medan dan kaedah hanya satu kelas. Jika anda perlu mewarisi sifat daripada lebih daripada satu sumber, Java menyediakan konsep antara muka, iaitu satu bentuk warisan berbilang.

?Antara muka adalah serupa dengan kelas. Walau bagaimanapun, mereka hanya mentakrifkan tandatangan kaedah dan bukan pelaksanaannya. Kaedah yang diisytiharkan dalam antara muka dilaksanakan dalam kelas. Pewarisan berbilang berlaku apabila kelas melaksanakan berbilang antara muka.

Di Java, warisan berbilang dicapai melalui antara muka dan bukannya kelas. Ini membolehkan kelas untuk melaksanakan berbilang antara muka, mewarisi tandatangan kaedah daripada setiap satu daripadanya. Di bawah ialah contoh yang menunjukkan berbilang warisan menggunakan antara muka.

Contoh Pewarisan Berbilang Menggunakan Antara Muka

Mari kita tentukan dua antara muka, Boleh Terbang dan Boleh Renang, dan Itik kelas yang melaksanakan kedua-dua antara muka.

Antara muka: Boleh terbang

public interface Flyable {
    void fly();
}

Antara muka: Boleh berenang

public interface Swimmable {
    void swim();
}

Kelas: Itik

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Penjelasan

1. Antaramuka:

   • Antara muka boleh terbang mentakrifkan kaedah fly().
   • Antara muka boleh renang mentakrifkan kaedah berenang().

2. Kelas:

   • Kelas itik melaksanakan kedua-dua antara muka Boleh Terbang dan Boleh Renang.
   • Kelas Duck menyediakan pelaksanaan untuk kedua-dua kaedah fly() dan swim().

3. Kaedah Utama:

   • Satu contoh Itik telah dibuat.
   • Kaedah fly() dan swim() dipanggil pada contoh Duck, menunjukkan bahawa kelas Duck telah mewarisi tingkah laku daripada kedua-dua antara muka.

Keluaran

Duck is flying
Duck is swimming

Berikut ialah rajah ringkas untuk menggambarkan perhubungan:

+----------------+
|    Flyable     |<--------------->Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |<--------------->Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |<--------------->Interface
|----------------|
| + swim()       |
+----------------+

Dalam contoh ini, kelas Itik menunjukkan berbilang warisan dengan melaksanakan kedua-dua antara muka Boleh Terbang dan Boleh Renang. Ini membolehkan kelas Duck mewarisi dan menyediakan pelaksanaan untuk kaedah yang ditakrifkan dalam kedua-dua antara muka, mempamerkan cara Java mencapai warisan berbilang melalui antara muka.

---

Kelas Abstrak di Jawa

Kelas abstrak dalam Java digunakan untuk menyediakan asas yang sama untuk keluarga kelas yang berkaitan. Ia boleh mengandungi kedua-dua kaedah abstrak (kaedah tanpa badan) dan kaedah konkrit (kaedah dengan badan). Di bawah ialah contoh yang menunjukkan penggunaan kelas abstrak.

Contoh Kelas Abstrak

Mari kita tentukan kelas abstrak Haiwan dan dua subkelas Anjing dan Kucing yang memanjangkan kelas Haiwan.

Kelas Abstrak: Haiwan

public abstract class Animal {
    // Abstract method (does not have a body)
    public abstract void makeSound();

    // Concrete method (has a body)
    public void sleep() {
        System.out.println("The animal is sleeping");
    }
}

Subkelas: Anjing

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

Subkelas: Kucing

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat says: Meow!");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
        cat.sleep();
    }
}

Penjelasan

1. Kelas Abstrak: Haiwan

   • Kelas Haiwan diisytiharkan sebagai abstrak, bermakna ia tidak boleh digunakan secara langsung.
   • Ia mengandungi kaedah abstrak makeSound(), yang mesti dilaksanakan oleh mana-mana subkelas.
   • Ia juga mengandungi kaedah konkrit sleep(), yang menyediakan pelaksanaan lalai.

2. Subkelas: Anjing

   • Kelas Anjing memanjangkan kelas Haiwan.
   • Ia menyediakan pelaksanaan untuk kaedah abstrak makeSound().
   • Kaedah utama mencipta instance Dog dan memanggil kaedah makeSound() dan sleep().

3. Subkelas: Kucing

   • Kelas Kucing memanjangkan kelas Haiwan.
   • Ia menyediakan pelaksanaan untuk kaedah abstrak makeSound().
   • Kaedah utama mencipta instance Cat dan memanggil kaedah makeSound() dan sleep().

Keluaran

Untuk kelas Anjing:

public interface Flyable {
    void fly();
}

Untuk kelas Kucing:

public interface Swimmable {
    void swim();
}

Berikut ialah rajah ringkas untuk menggambarkan perhubungan:

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Dalam contoh ini, kelas abstrak Haiwan menyediakan asas yang sama untuk subkelas Anjing dan Kucing. Kelas Haiwan mentakrifkan kaedah abstrak makeSound() yang mesti dilaksanakan oleh mana-mana subkelas, dan kaedah konkrit sleep() yang menyediakan pelaksanaan lalai. Kelas Anjing dan Kucing memanjangkan kelas Haiwan dan menyediakan pelaksanaan kaedah makeSound() mereka sendiri.

Perkara Utama Mengenai Antara Muka

1. Abstraksi: Antara muka dalam Java ialah mekanisme untuk mencapai abstraksi.
2. Kaedah Lalai: Secara lalai, kaedah antara muka adalah abstrak dan awam.
3. Jenis Kaedah: Kaedah antara muka boleh menjadi awam, peribadi, abstrak, lalai, statik dan strictfp sahaja.
4. Jenis Medan: Medan antara muka (pembolehubah) boleh menjadi awam, statik atau muktamad sahaja.
5. Hubungan IS-A: Antara Muka Java juga mewakili hubungan IS-A.
6. Instantiation: Ia tidak boleh instantiate terus, sama seperti kelas abstrak.
7. Gandingan Longgar: Ia boleh digunakan untuk mencapai gandingan longgar.
8. Abstrak Tersirat: Setiap antara muka adalah abstrak secara tersirat.
9. Kaedah Lalai: kaedah lalai hanya dibenarkan dalam antara muka.

Duck is flying
Duck is swimming

Aplikasi Praktikal

Menggunakan Antara Muka

Antara muka biasanya digunakan untuk mentakrifkan API, rangka kerja dan perpustakaan. Contohnya, antara muka java.util.List menyediakan kontrak untuk pelaksanaan senarai, seperti ArrayList dan LinkedList.

+----------------+
|    Flyable     |<--------------->Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |<--------------->Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |<--------------->Interface
|----------------|
| + swim()       |
+----------------+

Menggunakan Kelas Abstrak

Kelas abstrak sering digunakan untuk menyediakan kelas asas untuk keluarga kelas yang berkaitan. Contohnya, kelas java.util.AbstractList menyediakan pelaksanaan rangka bagi antara muka Senarai, mengurangkan jumlah kod yang perlu dilaksanakan oleh subkelas.

public interface Flyable {
    void fly();
}

---

Perbezaan Antara Antara Muka dan Kelas Abstrak

SNo	Interface	Abstract Class
1	Interfaces cannot be instantiated	Abstract classes cannot be instantiated
2	It can have both abstract and non-abstract methods	It can have both abstract and non-abstract methods
3	In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public	In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods
4	Interface supports multiple inheritance. Multiple interfaces can be implemented	Abstract class or class can extend only one class
5	It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes	It is used if you want to share code among several closely related classes
6	It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior.	It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private)

Ruj: https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Apabila kelas abstrak disubkelaskan, subkelas biasanya menyediakan pelaksanaan untuk semua kaedah abstrak dalam kelas induknya. Walau bagaimanapun, jika tidak, maka subkelas juga mesti diisytiharkan abstrak.

---

Pendapat Pakar

Menurut Joshua Bloch, pengarang "Effective Java," antara muka diutamakan berbanding kelas abstrak untuk menentukan jenis kerana ia lebih fleksibel dan menyokong pelbagai warisan. Walau bagaimanapun, kelas abstrak berguna untuk menyediakan fungsi dikongsi dan mengurangkan pertindihan kod.

"Antara muka sesuai untuk mentakrifkan campuran. Sebaliknya, kelas sesuai untuk menentukan objek yang mempunyai sifat intrinsik."

• Joshua Bloch

Sorotan

• Antaramuka: Sesuai untuk menentukan kontrak dan menyokong pelbagai warisan.
• Kelas Abstrak: Sesuai untuk menyediakan asas yang sama untuk kelas yang berkaitan, berkongsi kod dan tingkah laku.
• Perbezaan: Antara muka hanya boleh mempunyai kaedah abstrak (sebelum Java 8), manakala kelas abstrak boleh mempunyai kaedah abstrak dan konkrit.
• Penggunaan: Antara muka digunakan untuk mentakrifkan API dan rangka kerja, manakala kelas abstrak digunakan untuk menyediakan pelaksanaan rangka.

Terokai Lebih Lanjut

Terokai kuasa antara muka dan kelas abstrak dalam projek Java anda sendiri. Eksperimen dengan mentakrifkan kontrak menggunakan antara muka dan menyediakan kefungsian dikongsi menggunakan kelas abstrak. Kongsi pandangan dan pengalaman anda dengan komuniti Java untuk menyumbang kepada pengetahuan dan pertumbuhan kolektif.

Sebarang pembetulan atau penambahan pada siaran ini dialu-alukan.

public interface Flyable {
    void fly();
}

Atas ialah kandungan terperinci Antara Muka dan Kelas Abstrak di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!