PHP Soyut Sınıf: Soyut Metotlar ve Ne Zaman Kullanılır

Bir PHP soyut sınıfı abstract class Name ile tanımlanır ve new ile oluşturulamaz. Diğer sınıflar için bir temeldir: özellikleri, bir yapıcısı ve tamamlanmış metotları olabilir, ayrıca her alt sınıfın uygulaması gereken gövdesiz abstract metotlar da içerebilir.

<?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() Shape içinde bir kez yazılır ve her alt sınıfın sağladığı area() metodunu çağırır. Soyut sınıf metodun var olduğunu garanti eder, bu yüzden describe() ona güvenebilir.

Soyut bir sınıf new ile oluşturulamaz

Soyut bir sınıf bilerek eksiktir: Shape::area() metodunun gövdesi yoktur, bu yüzden düz bir Shape nesnesinin çalıştıracak hiçbir şeyi olmazdı. PHP onu oluşturmayı reddeder ve bir Error fırlatır:

<?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());

Soyut metotlar: kurallar

Soyut bir metodun gövde yerine bir imzası ve bir noktalı virgülü vardır. Her alt sınıf onu uyumlu bir imza ve aynı ya da daha geniş görünürlükle uygulamalıdır: bir abstract protected metot alt sınıfta protected veya public olabilir, asla private olamaz. Tek bir soyut metodu olan bir sınıfın kendisi de soyut olarak tanımlanmalıdır.

<?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";

Bir soyut metodu atlayan bir alt sınıf, alt sınıf da soyut olarak tanımlanıp metodu kendi alt sınıflarına bırakmadıkça, betiği daha hiçbir kısmı çalışmadan durdurur:

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

Şablon metot kalıbı

Soyut sınıf yazmanın en yaygın nedeni: birkaç adımın farklılaştığı sabit bir adım dizisi. Temel sınıf diziyi final bir metotta tutar ve alt sınıflar adımları doldurur. Burada aynı rapor hem düz metin hem HTML tablo olarak çalışır:

<?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>';

Çalıştırın, Page sekmesi düz metin sürümünün üstünde HTML tabloyu gösterir. open() ve close() metotlarının varsayılan gövdeleri vardır, bu yüzden yalnızca HtmlReport onları ezmeye gerek duyar; row() ise mantıklı bir varsayılanı olmadığı için soyuttur. render() metodunu final yapmak bir alt sınıfın adımların sırasını değiştirmesini önler.

Soyut bir sınıf bir arayüzü uygulayabilir

Soyut bir sınıf implements bildirebilir ve arayüzün bazı metotlarını alt sınıflarına bırakabilir. Bir arayüzü (tür) bir temel sınıfla (paylaşılan kod) eşleştirmenin standart yolu budur:

<?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);

Kod Cache arayüzünü tür ipucu olarak kullanır, bu yüzden BaseCache sınıfını genişletemeyen (çünkü zaten başka bir şeyi genişleten) bir sınıf yine de Cache arayüzünü doğrudan uygulayabilir.

Soyut sınıf ne zaman kullanılır, ne zaman kullanılmaz

Bir ailedeki sınıflar gerçek kod paylaştığında soyut sınıfa başvurun: özellikler, bir yapıcı, hepsi için aynı olan metotlar. Temel sınıf yalnızca soyut metotlardan oluşacaksa kılık değiştirmiş bir arayüzdür ve bir sınıf birçok arayüz uygulayabilip yalnızca bir sınıfı genişletebildiği için arayüz daha iyi bir seçimdir. Yalnızca ilişkisiz sınıflar arasında birkaç yardımcı metot paylaşmak istiyorsanız onları tek bir üst sınıfın altına zorlamak yerine bir trait kullanın.

abstract class yazmadan önce hızlı bir test: her alt sınıf gerçekten temel sınıfın bir türü mü (Circle bir Shape dir)? Dürüst yanıt "bunlardan biri" değil de "bunu yapabilir" ise bir arayüz yazın.