Inheritance, Interfaces & Traits

<?php
declare(strict_types=1);

class Employee
{
    public function __construct(
        protected string $name,
        protected float $salary,
    ) {}

    public function describe(): string
    {
        return "{$this->name} earns {$this->salary}";
    }

    public function annualCost(): float
    {
        return $this->salary * 12;
    }
}

class Manager extends Employee
{
    private array $reports = [];

    public function __construct(string $name, float $salary, private float $bonus)
    {
        parent::__construct($name, $salary);      // let the parent set its part
    }

    public function addReport(Employee $e): void
    {
        $this->reports[] = $e;
    }

    #[\Override]
    public function annualCost(): float
    {
        return parent::annualCost() + $this->bonus; // extend, do not repeat
    }

    #[\Override]
    public function describe(): string
    {
        return parent::describe() . " and manages " . count($this->reports);
    }
}

$dev = new Employee('Ravi', 90000);
$lead = new Manager('Asha', 150000, 200000);
$lead->addReport($dev);

echo $dev->describe(), "\n";
echo $lead->describe(), "\n";
echo $lead->annualCost(), "\n";
var_dump($lead instanceof Employee, $dev instanceof Manager);
echo get_parent_class($lead), "\n";

<?php
declare(strict_types=1);

class Notifier
{
    public function send(string $to, string $msg): bool
    {
        echo "generic: $to <- $msg\n";
        return true;
    }

    final public function sendAll(array $recipients, string $msg): int
    {
        $sent = 0;
        foreach ($recipients as $r) {
            if ($this->send($r, $msg)) {        // calls the child's send()
                $sent++;
            }
        }
        return $sent;
    }
}

class SmsNotifier extends Notifier
{
    #[\Override]
    public function send(string $to, string $msg, bool $flash = false): bool
    {
        if (strlen($msg) > 20) {
            echo "sms to $to: too long, skipped\n";
            return false;
        }
        echo "sms to $to: $msg\n";
        return true;
    }
}

final class EmailNotifier extends Notifier
{
}

$sms = new SmsNotifier();
echo $sms->sendAll(['98450', '98860'], 'OTP 4411'), " sent\n";
echo $sms->sendAll(['98450'], 'This message is far too long'), " sent\n";
echo (new EmailNotifier())->sendAll(['[email protected]'], 'Hi'), " sent\n";

<?php
declare(strict_types=1);

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

    abstract public function area(): float;      // no body: children write it

    public function describe(): string           // shared code that uses it
    {
        return sprintf("%s with area %.2f", $this->label, $this->area());
    }
}

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

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

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

$shapes = [new Circle(1), new Rectangle(3, 4.5)];
foreach ($shapes as $s) {
    echo $s->describe(), "\n";
}

<?php
declare(strict_types=1);

interface HasId
{
    public function id(): string;
}

interface Payable
{
    public const CURRENCY = 'INR';                // interface constant

    public function amountDue(): int;             // in paise
}

final class Invoice implements HasId, Payable     // several interfaces
{
    public function __construct(private string $number, private int $total) {}

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

    public function amountDue(): int
    {
        return $this->total;
    }
}

final class Subscription implements Payable
{
    public function __construct(private int $monthly, private int $months) {}

    public function amountDue(): int
    {
        return $this->monthly * $this->months;
    }
}

function collect(Payable ...$items): string       // any Payable fits
{
    $sum = 0;
    foreach ($items as $item) {
        $sum += $item->amountDue();
        if ($item instanceof HasId) {
            echo "billing ", $item->id(), "\n";
        }
    }
    return number_format($sum / 100, 2) . " " . Payable::CURRENCY;
}

echo collect(new Invoice('1042', 250000), new Subscription(49900, 3)), "\n";

<?php
declare(strict_types=1);

interface DiscountRule
{
    public function apply(float $total): float;
}

final class NoDiscount implements DiscountRule
{
    public function apply(float $total): float
    {
        return $total;
    }
}

final class PercentOff implements DiscountRule
{
    public function __construct(private float $percent) {}

    public function apply(float $total): float
    {
        return $total * (1 - $this->percent / 100);
    }
}

final class FlatOff implements DiscountRule
{
    public function __construct(private float $amount) {}

    public function apply(float $total): float
    {
        return max(0.0, $total - $this->amount);
    }
}

function checkout(float $total, DiscountRule $rule): string
{
    return $rule::class . ": " . number_format($rule->apply($total), 2);
}

foreach ([new NoDiscount(), new PercentOff(10), new FlatOff(150)] as $rule) {
    echo checkout(1000, $rule), "\n";
}

<?php
declare(strict_types=1);

trait Timestamps
{
    private array $touches = [];

    public function touch(string $when): void
    {
        $this->touches[] = $when;
    }

    public function lastTouched(): ?string
    {
        return $this->touches === [] ? null : $this->touches[array_key_last($this->touches)];
    }
}

trait SoftDeletes
{
    private bool $deleted = false;

    public function delete(): void
    {
        $this->deleted = true;
    }

    public function isDeleted(): bool
    {
        return $this->deleted;
    }
}

class Post
{
    use Timestamps, SoftDeletes;          // both traits' members are copied in

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

class Comment
{
    use Timestamps;
}

$p = new Post('Hello');
$p->touch('Jan 05');
$p->touch('Jan 09');
$p->delete();
echo $p->lastTouched(), " ", var_export($p->isDeleted(), true), "\n";

$c = new Comment();
var_dump($c->lastTouched());
echo implode(", ", class_uses($p)), "\n";

<?php
trait EmailSender
{
    public function send(): string
    {
        return "email sent";
    }
}

trait SmsSender
{
    public function send(): string
    {
        return "sms sent";
    }
}

class Notifier
{
    use EmailSender, SmsSender {
        EmailSender::send insteadof SmsSender;            // send() = email
        SmsSender::send as sendSms;                        // keep sms as sendSms()
        EmailSender::send as protected sendEmailInternal;  // alias + visibility
    }
}

$n = new Notifier();
echo $n->send(), " / ", $n->sendSms(), "\n";
var_dump(method_exists($n, 'sendEmailInternal'), is_callable([$n, 'sendEmailInternal']));

<?php
declare(strict_types=1);

class Model
{
    public static function create(): static
    {
        return new static();                  // the class that was called
    }

    public static function createSelf(): self
    {
        return new self();                    // always Model
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }
}

class User extends Model
{
}

class Order extends Model
{
}

echo get_class(User::create()), "\n";
echo get_class(User::createSelf()), "\n";
echo User::table(), " ", Order::table(), "\n";

<?php
declare(strict_types=1);

final class Playlist implements Countable, IteratorAggregate, Stringable
{
    private array $songs = [];

    public function __construct(private string $name) {}

    public function add(string $song): static
    {
        $this->songs[] = $song;
        return $this;
    }

    public function count(): int                // Countable: count($obj)
    {
        return count($this->songs);
    }

    public function getIterator(): Iterator     // IteratorAggregate: foreach
    {
        return new ArrayIterator($this->songs);
    }

    public function __toString(): string         // Stringable: echo $obj
    {
        return "{$this->name} ({$this->count()} songs)";
    }
}

$p = (new Playlist('Focus'))->add('Raga One')->add('Lo-fi Two')->add('Rain');
echo count($p), "\n";
foreach ($p as $i => $song) {
    echo $i + 1, ". $song\n";
}
echo $p, "\n";

function show(Stringable|string $x): void
{
    echo "> $x\n";
}
show($p);
show("plain text");