Classes & Objects

<?php
class BankAccount
{
    public string $owner = '';
    public float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;
    }

    public function describe(): string
    {
        return "{$this->owner} has {$this->balance}";
    }
}

$acc = new BankAccount();
$acc->owner = 'Asha';
$acc->deposit(500);
$acc->deposit(250.5);
echo $acc->describe(), "\n";

$other = new BankAccount();            // a separate object, its own data
$other->owner = 'Ravi';
echo $other->describe(), "\n";

var_dump($acc instanceof BankAccount);
echo get_class($acc), "\n";

<?php
declare(strict_types=1);

// the long way
class Product
{
    public string $name;
    public float $price;

    public function __construct(string $name, float $price)
    {
        $this->name = $name;
        $this->price = $price;
    }
}

// constructor property promotion: declare + assign in one place
class Customer
{
    public function __construct(
        public string $name,
        public string $email,
        private int $points = 0,
    ) {}

    public function addPoints(int $n): static
    {
        $this->points += $n;
        return $this;              // returning $this allows chaining
    }

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

$p = new Product('Keyboard', 1499.0);
echo "$p->name costs $p->price\n";

$c = new Customer('Asha', '[email protected]');
echo $c->addPoints(10)->addPoints(5)->points(), "\n";

$d = new Customer(email: '[email protected]', name: 'Ravi', points: 100);
echo "{$d->name}: {$d->points()}\n";

<?php
declare(strict_types=1);

class Account
{
    private float $balance = 0;
    public private(set) array $history = [];   // read anywhere, write inside only

    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException("Deposit must be positive");
        }
        $this->balance += $amount;
        $this->log("deposit $amount");
    }

    public function balance(): float
    {
        return $this->balance;
    }

    private function log(string $entry): void
    {
        $this->history[] = $entry;
    }
}

$acc = new Account();
$acc->deposit(100);
$acc->deposit(40);
echo $acc->balance(), "\n";
echo implode(" | ", $acc->history), "\n";

try {
    $acc->deposit(-5);
} catch (InvalidArgumentException $e) {
    echo "rejected: ", $e->getMessage(), "\n";
}

<?php
declare(strict_types=1);

final class Money
{
    public function __construct(
        public readonly int $amount,        // in paise: never float for money
        public readonly string $currency,
    ) {}

    public function add(Money $other): Money
    {
        return new Money($this->amount + $other->amount, $this->currency);
    }
}

$a = new Money(50000, 'INR');
$b = $a->add(new Money(2550, 'INR'));
echo $a->amount, " ", $b->amount, " ", $b->currency, "\n";

readonly class Point                       // every property is readonly
{
    public function __construct(public int $x, public int $y) {}

    public function withX(int $x): static
    {
        return clone($this, ['x' => $x]);  // PHP 8.5: clone with new values
    }
}
$p = new Point(1, 2);
$q = $p->withX(10);
echo "($p->x, $p->y) ($q->x, $q->y)\n";

class Draft
{
    public ?string $title = null;   // nullable with a default: initialised
    public string $body;            // no default: uninitialised
}
$d = new Draft();
var_dump($d->title, isset($d->body));

<?php
declare(strict_types=1);

class Order
{
    public const string STATUS_NEW = 'new';    // typed constant, PHP 8.3
    public const TAX_RATE = 0.18;

    private static int $created = 0;           // shared by all orders

    public function __construct(
        public readonly int $id,
        public string $status = self::STATUS_NEW,
    ) {
        self::$created++;
    }

    public static function count(): int
    {
        return self::$created;
    }

    public static function fromArray(array $row): self   // named constructor
    {
        return new self((int) $row['id'], $row['status'] ?? self::STATUS_NEW);
    }

    public function total(float $subtotal): float
    {
        return round($subtotal * (1 + self::TAX_RATE), 2);
    }
}

$a = new Order(1);
$b = Order::fromArray(['id' => '2', 'status' => 'paid']);
echo $a->status, " ", $b->status, " ", $b->id, "\n";
echo Order::count(), " orders, tax ", Order::TAX_RATE, "\n";
echo $a->total(1000), "\n";

<?php
class Customer
{
    public function __construct(public string $name) {}
}

class Cart
{
    public array $items = [];

    public function __construct(public Customer $owner) {}

    public function __clone()
    {
        $this->owner = clone $this->owner;   // deep-copy the inner object
    }
}

$c1 = new Cart(new Customer('Asha'));
$c2 = $c1;                                   // same object
$c2->items[] = 'pen';
echo count($c1->items), "\n";

$c3 = clone $c1;                             // new object (runs __clone)
$c3->items[] = 'ink';
$c3->owner->name = 'Ravi';
echo count($c1->items), " ", count($c3->items), "\n";
echo $c1->owner->name, " ", $c3->owner->name, "\n";

var_dump($c1 === $c2, $c1 === $c3, $c1 == $c3);

function renameCustomer(Customer $c): void
{
    $c->name = 'Changed';                    // no & needed
}
$x = new Customer('Kiran');
renameCustomer($x);
echo $x->name, "\n";

<?php
declare(strict_types=1);

enum Suit
{
    case Hearts;
    case Spades;
}

enum Status: string
{
    case Active = 'active';
    case Suspended = 'suspended';
    case Closed = 'closed';

    public function label(): string
    {
        return match ($this) {
            Status::Active => 'Active account',
            Status::Suspended => 'Temporarily blocked',
            Status::Closed => 'Closed for good',
        };
    }

    public function canLogIn(): bool
    {
        return $this === self::Active;
    }
}

$s = Suit::Hearts;
var_dump($s === Suit::Hearts, $s instanceof Suit);
echo $s->name, "\n";

$status = Status::from('suspended');           // from a database value
echo $status->name, " / ", $status->value, " / ", $status->label(), "\n";
var_dump($status->canLogIn());

var_dump(Status::tryFrom('deleted'));          // null instead of an error
echo implode(", ", array_map(fn(Status $s) => $s->value, Status::cases())), "\n";

function describe(Status $s): string           // only a Status fits
{
    return $s->label();
}
echo describe(Status::Closed), "\n";

<?php
declare(strict_types=1);

class Temperature
{
    public function __construct(public float $celsius) {}

    public float $fahrenheit {                  // no stored value: computed
        get => $this->celsius * 9 / 5 + 32;
        set(float $value) {
            $this->celsius = ($value - 32) * 5 / 9;
        }
    }

    public function __toString(): string
    {
        return sprintf("%.1f C", $this->celsius);
    }
}

class Subscriber
{
    public string $email {
        set(string $value) {                    // validate on every write
            if (!str_contains($value, '@')) {
                throw new InvalidArgumentException("Not an email: $value");
            }
            $this->email = strtolower($value);
        }
    }
}

$t = new Temperature(100);
echo $t->fahrenheit, "\n";
$t->fahrenheit = 50;
echo $t, "\n";                                  // calls __toString
echo "Now: $t\n";
var_dump($t instanceof Stringable);

$s = new Subscriber();
$s->email = '[email protected]';
echo $s->email, "\n";
try {
    $s->email = 'nope';
} catch (InvalidArgumentException $e) {
    echo $e->getMessage(), "\n";
}