Apakah perbezaan antara antara muka dan kelas abstrak?

Question

Accepted Answer

Kedua-duanya mentakrifkan jenis abstrak yang tidak boleh dikeluarkan secara langsung dan dimaksudkan untuk dilaksanakan/dilanjutkan — tetapi mereka melayani tujuan reka bentuk yang berbeza. Perbezaan utamanya ialah **pewarisan berganda**, **keadaan**, dan perhubungan yang dimodelkan.

## Antara muka — kontrak ("boleh-buat" / keupayaan)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Antara muka mentakrifkan **kontrak** tingkah laku. Sebuah kelas boleh melaksanakan **pelbagai** antara muka — ini adalah cara Java mencapai bentuk pewarisan berganda. Antara muka (secara tradisional) tidak mempunyai keadaan contoh.

## Kelas abstrak — asas separa ("ialah-a" dengan kod bersama)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Kelas abstrak boleh memegang **keadaan (medan)**, **pembina**, dan kaedah konkrit dengan pelaksanaan bersama — tetapi kelas hanya boleh memanjangkan **satu** kelas abstrak (pewarisan tunggal).

## Perbezaan utama

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Bila menggunakan yang mana

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Mengapa ini penting

Memilih antara antara muka dan kelas abstrak adalah keputusan reka bentuk asas Java.

Antara muka mentakrifkan **kontrak/keupayaan** dan membolehkan kelas melaksanakan banyak daripadanya (jawapan Java kepada pewarisan berganda) — sesuai untuk kebolehan merentas.

Kelas abstrak menyediakan **asas bersama dengan keadaan dan pelaksanaan separa** untuk subkelas yang berkaitan rapat, tetapi mengehadkan anda kepada pewarisan tunggal.

Memahami pertukaran (pelaksanaan berganda vs keadaan/pembina bersama, keupayaan vs perhubungan adalah-a) membimbing reka bentuk API dan hierarki kelas yang baik.

Dengan kaedah lalai Java 8+ yang mengaburkan garisan, mengetahui bila setiap sesuai — dan kekangan teras (satu kelas abstrak tetapi banyak antara muka, keadaan hanya dalam kelas abstrak) — penting untuk mereka bentuk kod yang fleksibel dan berstruktur dengan baik.