Bagaimana cara kerja inheritance, abstract classes, dan interfaces?

Question

Accepted Answer

PHP mendukung inheritance OOP dan abstraksi melalui tiga mekanisme terkait: **class inheritance** (`extends`), **abstract classes** (partial base classes), dan **interfaces** (contracts). Masing-masing memiliki tujuan desain yang berbeda.

## Inheritance — extend a parent class

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

Sebuah subclass `extends` parent, mewarisi dan secara opsional mengoverride anggotanya. `parent::` memanggil parent method yang di-override. PHP mendukung **single inheritance** (hanya satu parent).

## Abstract classes — a partial base (tidak bisa di-instantiate)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

Sebuah **abstract class** menggabungkan abstract methods (subclass harus mengimplementasikannya) dengan concrete shared code — sebuah base yang tidak bisa di-instantiate secara langsung.

## Interfaces — pure contracts (multiple allowed)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

Sebuah **interface** mendefinisikan contract (method signatures, tanpa implementasi). Sebuah class bisa `implement` **banyak** interfaces — cara PHP mengatasi single inheritance untuk berbagi capabilities.

## When to use which

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Mengapa ini penting

Inheritance, abstract classes, dan interfaces adalah tools OOP inti, dan memahami perbedaannya penting untuk merancang aplikasi PHP yang terstruktur dengan baik (dan untuk bekerja dengan frameworks, yang banyak mengandalkan hal-hal ini). **Inheritance** (`extends`) menyediakan code reuse melalui hubungan "is-a", tetapi PHP hanya memungkinkan single inheritance. **Abstract classes** menyediakan shared base dengan kode yang sudah diimplementasikan dan methods yang subclass harus definisikan — bagus untuk classes yang closely-related berbagi logic. **Interfaces** mendefinisikan contracts/capabilities, dan yang penting adalah sebuah class bisa mengimplementasikan **banyak** interfaces — membuat interfaces menjadi kunci untuk desain yang fleksibel dan decoupled serta jawaban PHP terhadap keterbatasan single-inheritance.

Mengetahui kapan menggunakan masing-masing (inheritance untuk is-a reuse, abstract classes untuk shared partial implementation, interfaces untuk contracts/capabilities), dan prinsip **programming to interfaces** (bergantung pada abstractions untuk testable, flexible, framework-friendly code), adalah pengetahuan penting untuk object-oriented PHP design.

Mekanisme-mekanisme ini mendasari bagaimana frameworks seperti Laravel dan Symfony menstruktur kode mereka (interfaces dan abstract base classes di mana-mana), menjadikannya essential baik untuk merancang kode Anda dengan baik maupun memahami frameworks yang Anda bangun.