Apa bedane antarane interface lan abstract class?

Question

Accepted Answer

Loro-lorone nggawe tipe abstrak sing ora bisa langsung diinstansiasi lan dimaksudne kanggo diimplementasikan/dipangkat — nanging layani tujuan desain sing beda. Pambeda utamane yaiku **inherited multipel**, **kondisi**, lan hubungan sing dimodelake.

## Interface — kontrak ("bisa-gawe" / kamampuan)

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

Interface nemtokake **kontrak** perilaku. Sawijining kelas bisa ngimplementasikan **multipel** interface — iki cara Java ngenteni wujud inherited multipel. Interface (sacara tradisional) ora duwe kondisi instansi.

## Abstract class — basis parsial ("iku-a" karo kode bareng)

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

Abstract class bisa nahan **kondisi (fields)**, **konstruktor**, lan metode konkreto karo implementasi bareng — nanging kelas cuma bisa mapantu **siji** abstract class (inherited tunggal).

## Pambeda kunci

```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 nggunakake sing 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)
```

## Apa gunane

Milih antarane interface lan abstract class yaiku keputusan desain dhasar Java.

Interface nemtokake **kontrak/kamampuan** lan ngandani kelas kanggo ngimplementasikan akeh-akeh (jawaban Java kanggo inherited multipel) — cocok kanggo kapabilitas lintas-potongan.

Abstract class nuduhake **basis bareng karo kondisi lan implementasi parsial** kanggo subkelas sing raket banget, nanging mbatesi sampeyan menyang inherited tunggal.

Mangerteni trade-off (implementasi multipel vs kondisi bareng/konstruktor, kamampuan vs hubungan iku-a) pandu desain API lan hierarki kelas sing apik.

Karo Java 8+ metode default sing ngersantoqake garis, ngerti kapan saben cocok — lan konstrain dhasar (saiji abstract class nanging akeh interface, kondisi mung ing abstract class) — penting kanggo ndesain kode sing fleksibel lan terstruktur kanthi apik.