Bagaimanakah inheritance, abstract class dan interface berfungsi?

Question

Accepted Answer

PHP menyokong inheritance dan abstraksi OOP melalui tiga mekanisme berkaitan: **class inheritance** (`extends`), **abstract class** (kelas asas separa), dan **interface** (kontrak). Setiap satu mempunyai tujuan reka bentuk yang berbeza.

## Inheritance — melanjutkan kelas induk

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

Subkelas `extends` induk, mewarisi dan secara pilihan mengatasi (override) ahlinya. `parent::` memanggil kaedah induk yang diatasi. PHP menyokong **single inheritance** (satu induk sahaja).

## Abstract class — kelas asas separa (tidak boleh 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
```

**Abstract class** menggabungkan kaedah abstract (subkelas mesti melaksanakannya) dengan kod kongsi konkrit — kelas asas yang tidak boleh di-instantiate secara langsung.

## Interface — kontrak tulen (berbilang dibenarkan)

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

**Interface** mentakrifkan kontrak (tandatangan kaedah, tanpa pelaksanaan). Sesuatu kelas boleh `implement` **banyak** interface — cara PHP mengatasi single inheritance untuk berkongsi keupayaan.

## Bila menggunakan yang mana

```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 ia penting

Inheritance, abstract class, dan interface ialah alat OOP teras, dan memahami perbezaannya adalah penting untuk mereka bentuk aplikasi PHP yang berstruktur baik (dan untuk bekerja dengan framework, yang banyak bersandar padanya). **Inheritance** (`extends`) menyediakan penggunaan semula kod melalui hubungan "is-a", tetapi PHP hanya membenarkan single inheritance. **Abstract class** menyediakan kelas asas kongsi dengan kedua-dua kod yang dilaksanakan dan kaedah yang mesti ditakrifkan oleh subkelas — baik untuk kelas yang berkait rapat yang berkongsi logik. **Interface** mentakrifkan kontrak/keupayaan, dan yang penting sesuatu kelas boleh melaksanakan **banyak** daripadanya — menjadikan interface kunci kepada reka bentuk yang fleksibel dan decoupled serta jawapan PHP kepada had single-inheritance.

Mengetahui bila menggunakan setiap satu (inheritance untuk penggunaan semula is-a, abstract class untuk pelaksanaan separa kongsi, interface untuk kontrak/keupayaan), dan prinsip **programming to interfaces** (bergantung pada abstraksi untuk kod yang boleh diuji, fleksibel, dan mesra-framework), ialah pengetahuan penting untuk reka bentuk PHP berorientasikan objek.

Mekanisme ini menyokong cara framework seperti Laravel dan Symfony menstrukturkan kodnya (interface dan kelas asas abstract di mana-mana), menjadikannya penting untuk kedua-dua mereka bentuk kod anda sendiri dengan baik dan memahami framework yang anda bina di atasnya.