Apa perbedaan antara interface dan abstract class?

Question

Accepted Answer

Keduanya mendefinisikan tipe abstrak yang tidak dapat diinstansiasi langsung dan dimaksudkan untuk diimplementasikan/diperluas — tetapi mereka melayani tujuan desain yang berbeda. Perbedaan utamanya adalah **multiple inheritance**, **state**, dan hubungan yang mereka modelkan.

## Interface — sebuah kontrak ("can-do" / kapabilitas)

```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 */ }
}
```

Sebuah interface mendefinisikan **kontrak** perilaku. Sebuah class dapat mengimplementasikan **multiple** interfaces — ini adalah bagaimana Java mencapai bentuk multiple inheritance. Interfaces (secara tradisional) tidak memiliki state instance.

## Abstract class — sebuah base sebagian ("is-a" dengan shared code)

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

Sebuah abstract class dapat menampung **state (fields)**, **constructors**, dan concrete methods dengan shared implementation — tetapi sebuah class hanya dapat extend satu abstract class (single inheritance).

## Perbedaan 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
```

## Kapan 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 interface dan abstract class adalah keputusan desain Java yang fundamental.

Interfaces mendefinisikan **contracts/capabilities** dan memungkinkan sebuah class untuk mengimplementasikan banyak dari mereka (jawaban Java untuk multiple inheritance) — ideal untuk kemampuan lintas-cutting.

Abstract classes menyediakan **shared base dengan state dan partial implementation** untuk closely-related subclasses, tetapi membatasi Anda pada single inheritance.

Memahami trade-offs (multiple-implementation vs shared-state/constructors, capability vs is-a relationship) memandu desain API dan class-hierarchy yang baik.

Dengan Java 8+ default methods yang mengaburkan batas-batasnya, mengetahui kapan masing-masing cocok — dan constraint inti (satu abstract class tetapi banyak interfaces, state hanya dalam abstract classes) — sangat penting untuk merancang code yang fleksibel dan terstruktur dengan baik.