Abstract Class PHP: Abstract Method dan Kapan Memakainya

Abstract class di PHP dideklarasikan dengan abstract class Name dan tidak bisa dibuat dengan new. Class ini menjadi dasar untuk class lain: isinya bisa property, constructor, dan method yang sudah lengkap, ditambah method abstract tanpa body yang wajib diimplementasikan oleh setiap class turunan.

<?php
abstract class Shape
{
    public function __construct(protected string $label) {}

    abstract public function area(): float;

    public function describe(): string
    {
        return sprintf('%s: %.2f', $this->label, $this->area());
    }
}

class Rectangle extends Shape
{
    public function __construct(private float $w, private float $h)
    {
        parent::__construct('Rectangle');
    }

    public function area(): float
    {
        return $this->w * $this->h;
    }
}

class Circle extends Shape
{
    public function __construct(private float $r)
    {
        parent::__construct('Circle');
    }

    public function area(): float
    {
        return M_PI * $this->r ** 2;
    }
}

foreach ([new Rectangle(3, 4), new Circle(1.5)] as $shape) {
    echo $shape->describe(), "\n";
}

describe() ditulis sekali di Shape dan memanggil area(), yang disediakan oleh setiap class turunan. Abstract class menjamin method itu ada, jadi describe() bisa mengandalkannya.

Abstract class tidak bisa dibuat dengan new

Abstract class sengaja dibuat tidak lengkap: Shape::area() tidak punya body, jadi objek Shape biasa tidak punya apa pun untuk dijalankan. PHP menolak membuatnya dan melempar Error:

<?php
abstract class Shape
{
    abstract public function area(): float;
}

try {
    $s = new Shape();
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

$r = new ReflectionClass('Shape');
var_dump($r->isAbstract());

Abstract method: aturannya

Abstract method punya signature dan titik koma, bukan body. Setiap class turunan harus mengimplementasikannya dengan signature yang kompatibel dan visibilitas yang sama atau lebih luas: method abstract protected boleh menjadi protected atau public di class turunan, tetapi tidak pernah private. Class yang punya satu saja abstract method wajib dideklarasikan abstract juga.

<?php
abstract class Notification
{
    public function __construct(protected string $recipient) {}

    abstract protected function channel(): string;

    abstract protected function format(string $text): string;

    public function send(string $text): string
    {
        return "[{$this->channel()}] to {$this->recipient}: " . $this->format($text);
    }
}

class SmsNotification extends Notification
{
    protected function channel(): string
    {
        return 'SMS';
    }

    protected function format(string $text): string
    {
        return rtrim(mb_substr($text, 0, 20)) . (mb_strlen($text) > 20 ? '...' : '');
    }
}

class EmailNotification extends Notification
{
    public function channel(): string   // protected widened to public: allowed
    {
        return 'Email';
    }

    protected function format(string $text): string
    {
        return "Hello,\n\n$text\n\nRegards";
    }
}

echo (new SmsNotification('+3912345'))->send('Your parcel arrives tomorrow between 9 and 12'), "\n\n";
echo (new EmailNotification('ada@example.com'))->send('Your parcel arrives tomorrow.'), "\n";

Class turunan yang melewatkan sebuah abstract method akan menghentikan script sebelum satu baris pun berjalan, kecuali class turunan itu juga dideklarasikan abstract dan menyerahkan method tersebut ke turunannya sendiri:

PHP Fatal error:  Class Square contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Shape::area) in /home/index.php on line 3

Pola template method

Alasan paling umum untuk menulis abstract class: ada urutan langkah yang tetap, dan hanya beberapa langkah yang berbeda. Class dasar memegang urutannya di sebuah method final, lalu class turunan mengisi langkah-langkahnya. Di sini laporan yang sama dijalankan sebagai teks biasa dan sebagai tabel HTML:

<?php
abstract class Report
{
    public function __construct(protected array $rows) {}

    final public function render(): string
    {
        $out = $this->open();
        foreach ($this->rows as $row) {
            $out .= $this->row($row);
        }
        return $out . $this->close();
    }

    abstract protected function row(array $row): string;

    protected function open(): string { return ''; }
    protected function close(): string { return ''; }
}

class TextReport extends Report
{
    protected function row(array $row): string
    {
        return str_pad($row[0], 10) . $row[1] . "\n";
    }
}

class HtmlReport extends Report
{
    protected function open(): string { return "<table border=\"1\">\n"; }
    protected function close(): string { return "</table>\n"; }

    protected function row(array $row): string
    {
        return '<tr><td>' . htmlspecialchars($row[0]) . '</td><td>' . $row[1] . "</td></tr>\n";
    }
}

$rows = [['Apples', 12], ['Pears', 7], ['Plums', 30]];
echo (new HtmlReport($rows))->render();
echo '<pre>' . (new TextReport($rows))->render() . '</pre>';

Jalankan, dan tab Halaman menampilkan tabel HTML di atas versi teks biasanya. open() dan close() punya body bawaan, jadi hanya HtmlReport yang perlu meng-override keduanya; row() dibuat abstract karena tidak ada nilai bawaan yang masuk akal. Menjadikan render() sebagai final mencegah class turunan mengubah urutan langkahnya.

Abstract class bisa mengimplementasikan interface

Abstract class boleh mendeklarasikan implements dan menyerahkan sebagian method dari interface itu ke class turunannya. Ini cara standar untuk memasangkan interface (tipenya) dengan class dasar (kode bersamanya):

<?php
interface Cache
{
    public function get(string $key): mixed;
    public function set(string $key, mixed $value): void;
    public function has(string $key): bool;
}

abstract class BaseCache implements Cache
{
    // has() is written once, in terms of get()
    public function has(string $key): bool
    {
        return $this->get($key) !== null;
    }
}

class ArrayCache extends BaseCache
{
    private array $items = [];

    public function get(string $key): mixed
    {
        return $this->items[$key] ?? null;
    }

    public function set(string $key, mixed $value): void
    {
        $this->items[$key] = $value;
    }
}

$cache = new ArrayCache();
$cache->set('user:1', 'Ada');
var_dump($cache->has('user:1'), $cache->has('user:2'));
var_dump($cache instanceof Cache);

Kode memakai type hint ke interface Cache, jadi class yang tidak bisa meng-extend BaseCache (karena sudah meng-extend class lain) tetap bisa mengimplementasikan Cache secara langsung.

Kapan memakai abstract class, dan kapan tidak

Pakai abstract class saat class dalam satu keluarga berbagi kode nyata: property, constructor, method yang sama untuk semuanya. Kalau class dasarnya hanya berisi abstract method, itu sebenarnya interface yang menyamar, dan interface adalah pilihan yang lebih baik karena sebuah class bisa mengimplementasikan banyak interface tetapi hanya bisa meng-extend satu class. Kalau kamu hanya ingin berbagi beberapa method bantu antar-class yang tidak berhubungan, pakai trait daripada memaksa semuanya di bawah satu induk.

Tes cepat sebelum menulis abstract class: apakah setiap class turunan benar-benar sejenis dengan class dasarnya (Circle adalah sebuah Shape)? Kalau jawaban jujurnya "ia bisa melakukan ini" alih-alih "ia adalah salah satu dari ini", tulislah interface.