Object-Oriented PHP 🏗️

<?php
// A class is a BLUEPRINT. It describes what every object made from it
// will hold (properties) and what it can do (methods). Nothing happens
// until you build an actual object from it with 'new'.

class Dog
{
    // Typed properties with visibility:
    //   public    -> readable/writable from anywhere
    //   private   -> only inside THIS class
    public string $name;     // the dog's name
    public int    $age;      // the dog's age in years
}

// 'new' builds an OBJECT (an instance) from the blueprint.
$rex = new Dog();   // $rex is now a Dog object

// Reach inside the object with -> to set its properties.
$rex->name = "Rex";
$rex->age  = 3;

echo "Name: {$rex->name}\n";   // {$rex->name} pulls the value back out
echo "Age:  {$rex->age}\n";

// Each object is independent — a second Dog has its own data.
$buddy = new Dog();
$buddy->name = "Buddy";
$buddy->age  = 7;

echo "Name: {$buddy->name}\n";
echo "Age:  {$buddy->age}\n";

Name: Rex
Age:  3
Name: Buddy
Age:  7

<?php
// Setting every property by hand (like the last example) is tedious and
// easy to forget. A CONSTRUCTOR fixes that: __construct() runs automatically
// the moment you write 'new', so an object is fully built in one line.

class Dog
{
    public string $name;
    public int    $age;

    // $this means "this particular object". $this->name is the property
    // on the object being built; $name is the value passed in.
    public function __construct(string $name, int $age)
    {
        $this->name = $name;   // store the argument on the object
        $this->age  = $age;
    }

    // A METHOD is a function that belongs to the class and can use $this.
    public function describe(): string
    {
        return "{$this->name} is {$this->age} years old";
    }
}

// The arguments go straight into __construct — no manual setup needed.
$rex   = new Dog("Rex", 3);
$buddy = new Dog("Buddy", 7);

echo $rex->describe() . "\n";     // calls the method with ->
echo $buddy->describe() . "\n";

Rex is 3 years old
Buddy is 7 years old

<?php
// PHP 8 CONSTRUCTOR PROPERTY PROMOTION: declare the property AND assign it
// in one step by putting the visibility keyword in the constructor signature.
// PHP creates the property and runs $this->x = $x for you. Same result,
// far less boilerplate.

class BankAccount
{
    // 'private' here both DECLARES $balance and assigns the argument to it.
    // 'protected' would let subclasses see it; 'public' anyone.
    public function __construct(
        public string $owner,        // promoted public property
        private float  $balance = 0, // promoted private property, default 0
    ) {}

    public function deposit(float $amount): void
    {
        $this->balance += $amount;   // private is reachable from INSIDE
    }

    public function getBalance(): float
    {
        return $this->balance;       // a 'getter' exposes it safely
    }
}

$acc = new BankAccount("Alice", 100);
$acc->deposit(50);

echo "Owner:   {$acc->owner}\n";              // public -> read directly
echo "Balance: {$acc->getBalance()}\n";       // private -> via the getter

Owner:   Alice
Balance: 150

<?php
// STATIC members belong to the CLASS itself, not to any one object.
// There is exactly one copy, shared by everything. Use Class::member to
// reach it — no 'new' required.

class Counter
{
    // A class CONSTANT never changes. By convention it's UPPER_CASE.
    const MAX = 100;

    // A static PROPERTY is shared across every object of the class.
    public static int $count = 0;

    public function __construct()
    {
        self::$count++;          // self:: = "this class" — bumps the shared count
    }

    // A static METHOD is called on the class, not an instance.
    public static function howMany(): string
    {
        // self::MAX reads the constant; self::$count reads the static property.
        return self::$count . " of " . self::MAX . " created";
    }
}

new Counter();   // each 'new' runs the constructor, so $count goes up
new Counter();
new Counter();

echo Counter::howMany() . "\n";   // Class::method() — no object needed
echo "MAX is " . Counter::MAX . "\n";

3 of 100 created
MAX is 100

<?php
// 🎯 YOUR TURN — build a Book class, then run it.
// Fill in each blank marked ___ using the 👉 hints.

class Book
{
    // 1) Declare two PUBLIC typed properties: a string $title and an int $pages
    ___ string $title;       // 👉 add the visibility keyword:  public
    public ___ $pages;       // 👉 add the type:  int

    // 2) Finish the constructor so it stores both arguments on the object
    public function __construct(string $title, int $pages)
    {
        $this->title = ___;  // 👉 the argument to save here is  $title
        ___->pages   = $pages;   // 👉 the object refers to itself as  $this
    }

    public function summary(): string
    {
        return "{$this->title} — {$this->pages} pages";
    }
}

$b = new Book("PHP Basics", 240);
echo $b->summary() . "\n";

// ✅ Expected output:
//    PHP Basics — 240 pages
?>

PHP Basics — 240 pages

<?php
// 🎯 YOUR TURN — finish the static counter, then run it.
// Replace each ___ using the 👉 hints.

class Robot
{
    public static int $built = 0;   // shared across ALL robots

    public function __construct()
    {
        // 1) Increase the SHARED counter by one.
        ___::$built++;              // 👉 "this class" keyword is  self
    }
}

new Robot();
new Robot();

// 2) Read the shared count off the CLASS, not an object.
echo Robot::___ . " robots built\n";   // 👉 the static property is  $built

// ✅ Expected output:
//    2 robots built
?>

2 robots built

<?php
// A READONLY property (PHP 8.1) can be set ONCE — usually in the constructor —
// then never changed again. Perfect for an ID or anything that must stay fixed.

class User
{
    public function __construct(
        public readonly int    $id,     // set once, then locked
        public string          $name,   // a normal, changeable property
    ) {}
}

$u = new User(1, "Alice");

echo "ID:   {$u->id}\n";
echo "Name: {$u->name}\n";

$u->name = "Alicia";   // fine — $name is a normal property
echo "Renamed to: {$u->name}\n";

// $u->id = 2;   // would crash: "Cannot modify readonly property User::\$id"
echo "ID is still: {$u->id}\n";

ID:   1
Name: Alice
Renamed to: Alicia
ID is still: 1