Inheritance, Interfaces and Abstract Classes

<?php

declare(strict_types=1);

class Item
{
    public function __construct(
        public readonly string $id,
        public readonly string $title,
    ) {}

    public function label(): string
    {
        return "{$this->title} ({$this->id})";
    }

    public function loanDays(): int
    {
        return 21;
    }
}

final class Dvd extends Item
{
    public function __construct(string $id, string $title, public readonly int $minutes)
    {
        parent::__construct($id, $title);       // not called automatically
    }

    #[\Override]                                 // 8.3: assert that this really overrides a parent method
    public function loanDays(): int
    {
        return 7;
    }

    #[\Override]
    public function label(): string
    {
        return 'DVD: ' . parent::label() . ", {$this->minutes} min";
    }
}

$items = [new Item('B-1', 'Kindred'), new Dvd('D-1', 'Solaris', 167)];
foreach ($items as $item) {
    printf("%-40s %d days\n", $item->label(), $item->loanDays());   // polymorphism: the object's class decides
}

Kindred (B-1)                            21 days
DVD: Solaris (D-1), 167 min              7 days

<?php

declare(strict_types=1);

abstract class Report
{
    final public function render(): string             // template method: fixed skeleton
    {
        return $this->header() . "\n" . implode("\n", $this->rows()) . "\n";
    }

    protected function header(): string { return strtoupper(static::TITLE); }

    /** @return list<string> */
    abstract protected function rows(): array;          // step implemented by subclasses
}

final class OverdueReport extends Report
{
    public const TITLE = 'Overdue loans';

    public function __construct(private array $loans) {}

    #[\Override]
    protected function rows(): array
    {
        return array_map(fn (array $l): string => "{$l['title']}: {$l['days']} days late", $this->loans);
    }
}

echo (new OverdueReport([['title' => 'Kindred', 'days' => 3]]))->render();
// OVERDUE LOANS
// Kindred: 3 days late

<?php

declare(strict_types=1);

interface Lendable
{
    public const int DEFAULT_DAYS = 21;             // interface constants (typed since 8.3)

    public string $title { get; }                   // 8.4: interface property

    public function loanDays(): int;
}

interface Reservable
{
    public function reserve(string $memberId): void;
}

interface Circulating extends Lendable, Reservable {}   // interfaces can extend several interfaces

final class Book implements Circulating, Stringable
{
    private array $queue = [];

    public function __construct(public readonly string $title) {}

    public function loanDays(): int { return self::DEFAULT_DAYS; }

    public function reserve(string $memberId): void { $this->queue[] = $memberId; }

    public function __toString(): string { return $this->title; }
}

function describe(Lendable&Reservable $item): string        // intersection type of two interfaces
{
    return "{$item->title}: {$item->loanDays()} days";
}

$book = new Book('Kindred');
echo describe($book), "\n";                              // Kindred: 21 days
var_dump($book instanceof Lendable, $book instanceof Circulating);   // bool(true) bool(true)

<?php

declare(strict_types=1);

class Item {}
final class Book extends Item {}

interface ItemFactory
{
    public function create(string $id): Item;
}

final class BookFactory implements ItemFactory
{
    public function create(string|int $id): Book       // wider parameter, narrower return: allowed
    {
        return new Book();
    }
}

interface ItemSink
{
    public function accept(Book $item): void;
}

final class AnythingSink implements ItemSink
{
    public function accept(Item $item): void {}          // contravariant parameter: allowed
}

var_dump((new BookFactory())->create(42) instanceof Book);   // bool(true)
// The reverse (parameter Item -> Book, or return Book -> Item) is a fatal error at compile time.

<?php

declare(strict_types=1);

/** @implements IteratorAggregate<string, string> @implements ArrayAccess<string, string> */
final class Catalogue implements IteratorAggregate, ArrayAccess, Countable, JsonSerializable
{
    /** @var array<string, string> isbn => title */
    private array $titles = [];

    public function getIterator(): Generator { yield from $this->titles; }

    public function offsetExists(mixed $isbn): bool { return isset($this->titles[$isbn]); }
    public function offsetGet(mixed $isbn): string { return $this->titles[$isbn] ?? throw new OutOfBoundsException("No {$isbn}"); }
    public function offsetSet(mixed $isbn, mixed $title): void { $this->titles[$isbn] = $title; }
    public function offsetUnset(mixed $isbn): void { unset($this->titles[$isbn]); }

    public function count(): int { return count($this->titles); }

    public function jsonSerialize(): array { return ['count' => count($this), 'titles' => array_values($this->titles)]; }
}

$c = new Catalogue();
$c['978-0-00-000001-1'] = 'Kindred';
$c['978-0-00-000003-5'] = 'Solaris';
unset($c['978-0-00-000003-5']);

foreach ($c as $isbn => $title) {
    echo "{$isbn} {$title}\n";
}
echo count($c), ' ', json_encode($c), "\n";                   // 1 {"count":1,"titles":["Kindred"]}
var_dump(isset($c['nope']));                                  // bool(false)

<?php

declare(strict_types=1);

interface FinePolicy { public function fineFor(int $daysLate): int; }

final class FlatFine implements FinePolicy
{
    public function fineFor(int $daysLate): int { return $daysLate * 25; }
}

final class CappedFine implements FinePolicy                 // a decorator: wraps another policy
{
    public function __construct(private FinePolicy $inner, private int $cap) {}
    public function fineFor(int $daysLate): int { return min($this->cap, $this->inner->fineFor($daysLate)); }
}

final class ReturnDesk                                        // composed, not inherited
{
    public function __construct(private FinePolicy $fines) {}
    public function checkIn(int $daysLate): string { return sprintf('Fine: %.2f EUR', $this->fines->fineFor($daysLate) / 100); }
}

echo (new ReturnDesk(new FlatFine()))->checkIn(60), "\n";                     // Fine: 15.00 EUR
echo (new ReturnDesk(new CappedFine(new FlatFine(), 1000)))->checkIn(60), "\n";   // Fine: 10.00 EUR