Advanced OOP Patterns 🏗️

<?php
// An interface is a CONTRACT: a list of methods (no bodies) that any
// class promising to be a "Shape" must provide. It defines WHAT, not HOW.
interface Shape
{
    public function area(): float;     // every shape must be able to report its area
    public function name(): string;    // ...and tell you what it is
}

// "implements Shape" = this class signs the contract. It MUST define
// both methods, or PHP refuses to run the file.
class Circle implements Shape
{
    public function __construct(private float $radius) {}

    public function area(): float { return 3.14159 * $this->radius ** 2; }
    public function name(): string { return "Circle"; }
}

class Rectangle implements Shape
{
    public function __construct(private float $w, private float $h) {}

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

// Because both honour the SAME contract, code can treat them identically.
// The type hint "Shape" accepts any class that implements it.
function describe(Shape $s): void
{
    printf("%-10s area = %.2f\n", $s->name(), $s->area());
}

describe(new Circle(2));        // Circle     area = 12.57
describe(new Rectangle(3, 4));  // Rectangle  area = 12.00

Circle     area = 12.57
Rectangle  area = 12.00

<?php
// An ABSTRACT class is a half-finished blueprint. You can't create one
// directly (no "new Animal()") — it exists only to be EXTENDED.
abstract class Animal
{
    public function __construct(protected string $name) {}

    // An abstract METHOD is a hole: no body here, every child must fill it.
    abstract public function speak(): string;

    // A NORMAL method: shared code every child inherits for free.
    public function introduce(): string
    {
        return "{$this->name} says " . $this->speak();
    }
}

// "extends Animal" inherits the constructor + introduce(), and fills speak().
class Dog extends Animal
{
    public function speak(): string { return "Woof!"; }
}

class Cat extends Animal
{
    public function speak(): string { return "Meow!"; }
}

$pets = [new Dog("Rex"), new Cat("Whiskers")];
foreach ($pets as $pet) {
    echo $pet->introduce() . "\n";   // uses inherited introduce() + each child's speak()
}

Rex says Woof!
Whiskers says Meow!

<?php
// A TRAIT is a reusable bundle of methods you can "paste" into ANY class —
// even unrelated ones. It solves single-inheritance: a class extends ONE
// parent but can "use" MANY traits.
trait Timestampable
{
    public function touch(): string { return "Updated at " . date("H:i", 0); }
}

trait Loggable
{
    public function log(string $msg): string { return "[LOG] $msg"; }
}

class Article
{
    use Timestampable, Loggable;   // mix BOTH traits into this one class
    public function __construct(public string $title) {}
}

$a = new Article("Hello");
echo $a->log("created") . "\n";   // method came from Loggable
echo $a->touch() . "\n";          // method came from Timestampable

// CONFLICT RESOLUTION: if two traits define the same method name, PHP errors
// unless you pick a winner with "insteadof" (and optionally rename with "as").
trait FileStore  { public function save(): string { return "Saved to file"; } }
trait CloudStore { public function save(): string { return "Saved to cloud"; } }

class Backup
{
    use FileStore, CloudStore {
        FileStore::save insteadof CloudStore;   // FileStore::save() wins
        CloudStore::save as saveToCloud;        // keep the other under a new name
    }
}

$b = new Backup();
echo $b->save() . "\n";          // Saved to file
echo $b->saveToCloud() . "\n";   // Saved to cloud

[LOG] created
Updated at 00:00
Saved to file
Saved to cloud

<?php
// A base class with shared behaviour.
class PaymentMethod
{
    public function __construct(protected float $amount) {}

    public function describe(): string
    {
        return "Paying $" . number_format($this->amount, 2);
    }

    // LATE STATIC BINDING: "static" resolves to the class that was CALLED,
    // not the one where this line is written. "new static()" builds a child.
    public static function of(float $amount): static
    {
        return new static($amount);
    }
}

class CardPayment extends PaymentMethod
{
    // OVERRIDE: same method name + matching signature, new behaviour.
    public function describe(): string
    {
        // "parent::" calls the version we just overrode, then we add to it.
        return parent::describe() . " by card";
    }
}

// FINAL: this class cannot be extended, and final methods cannot be overridden.
final class CashPayment extends PaymentMethod
{
    public function describe(): string
    {
        return parent::describe() . " in cash";
    }
}

// POLYMORPHISM: one variable, many forms. Each $p runs ITS OWN describe().
$payments = [new CardPayment(50), new CashPayment(30), new PaymentMethod(10)];
foreach ($payments as $p) {
    echo $p->describe() . "\n";
}

// Late static binding pay-off: of() lives in the parent but builds the child.
$card = CardPayment::of(99.99);
echo get_class($card) . " => " . $card->describe() . "\n";

Paying $50.00 by card
Paying $30.00 in cash
Paying $10.00
CardPayment => Paying $99.99 by card

<?php
// These OOP features are the bricks behind classic design patterns.

// STRATEGY: an interface + interchangeable implementations you swap at runtime.
interface DiscountStrategy
{
    public function apply(float $total): float;
}

class NoDiscount   implements DiscountStrategy { public function apply(float $t): float { return $t; } }
class TenPercent   implements DiscountStrategy { public function apply(float $t): float { return $t * 0.9; } }
class FlatFiveOff  implements DiscountStrategy { public function apply(float $t): float { return max(0, $t - 5); } }

class Checkout
{
    // The client holds a DiscountStrategy but doesn't care which one it is.
    public function __construct(private DiscountStrategy $discount) {}
    public function total(float $subtotal): float { return $this->discount->apply($subtotal); }
}

echo "Strategy:\n";
foreach ([new NoDiscount(), new TenPercent(), new FlatFiveOff()] as $strategy) {
    $checkout = new Checkout($strategy);
    printf("  %-12s -> $%.2f\n", get_class($strategy), $checkout->total(100));
}

// FACTORY: a static method that returns the right object for a type string,
// so callers never write "new SomethingSpecific()" themselves.
class DiscountFactory
{
    public static function make(string $type): DiscountStrategy
    {
        return match ($type) {
            "none"  => new NoDiscount(),
            "loyal" => new TenPercent(),
            "promo" => new FlatFiveOff(),
            default => throw new InvalidArgumentException("Unknown: $type"),
        };
    }
}

echo "Factory:\n";
$strategy = DiscountFactory::make("loyal");        // factory picks the class
echo "  loyal -> $" . number_format((new Checkout($strategy))->total(100), 2) . "\n";

Strategy:
  NoDiscount   -> $100.00
  TenPercent   -> $90.00
  FlatFiveOff  -> $95.00
Factory:
  loyal -> $90.00

<?php
// 🎯 YOUR TURN — finish the contract and sign it.
// A "Greeter" must be able to greet(). Make EnglishGreeter honour it.

interface Greeter
{
    public function greet(): string;   // the contract: one method, no body
}

// 1) Make this class sign the contract.
class EnglishGreeter ___ Greeter   // 👉 the keyword that signs an interface
{
    // 2) Fill the contract method so it returns the word "Hello".
    public function greet(): string { return ___; }   // 👉 "Hello" in double quotes
}

$g = new EnglishGreeter();
echo $g->greet() . "\n";

// ✅ Expected output:
//    Hello

Hello

<?php
// 🎯 YOUR TURN — extend an abstract class and call the parent.

abstract class Vehicle
{
    public function __construct(protected string $name) {}
    abstract public function wheels(): int;          // child must fill this hole
    public function describe(): string { return "{$this->name} has " . $this->wheels() . " wheels"; }
}

// 1) Make Motorbike build on Vehicle.
class Motorbike ___ Vehicle        // 👉 the keyword that inherits a class
{
    // 2) A motorbike has 2 wheels — return that number.
    public function wheels(): int { return ___; }   // 👉 a whole number
}

$m = new Motorbike("Harley");
echo $m->describe() . "\n";

// ✅ Expected output:
//    Harley has 2 wheels

Harley has 2 wheels