Chapter 06 · OOP Foundations

Visibility & Encapsulation

So far our properties have all been public — anyone can reach in and change them, even to nonsense values. Real objects protect themselves. This chapter teaches the three visibility keywords and the famous getter/setter pattern.

The danger of public everything

class BankAccount {
    public float $balance = 0;
}

$acc = new BankAccount();
$acc->balance = -5000000;   // 😱 anyone can do this! The bank now owes... wait, what?

Nothing stops that line. In a big project with many programmers (or just tired-you at 2 a.m.), somebody will write a line like that eventually. We need locks.

The three visibility keywords

Locking the vault with private

<?php
class BankAccount {
    private float $balance = 0;     // 🔒 locked inside

    public function deposit(float $amount): void {
        if ($amount <= 0) {
            echo "Deposit must be positive.<br>";
            return;
        }
        $this->balance += $amount;
    }

    public function withdraw(float $amount): void {
        if ($amount > $this->balance) {
            echo "Insufficient funds.<br>";
            return;
        }
        $this->balance -= $amount;
    }

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

$acc = new BankAccount();
$acc->deposit(1000);
$acc->withdraw(300);
echo "Balance: K" . $acc->getBalance() . "<br>";

$acc->balance = -5000000;   // 💥 Fatal error: Cannot access private property

Beautiful! The dangerous line now crashes immediately instead of silently corrupting our data. Inside the class, methods still use $this->balance freely — the lock only keeps outsiders out. Every coin now enters through deposit() and leaves through withdraw(), and both doors have rules.

Getters and setters — the official doors

The pattern you just saw has a name. A getter is a method that reads a private property (getBalance()). A setter is a method that changes one — after checking the new value makes sense:

class Student {
    private string $name;
    private int $age;

    public function __construct(string $name, int $age) {
        $this->setName($name);   // even the constructor uses the setter — one door, one rule
        $this->setAge($age);
    }

    // ---- getters ----
    public function getName(): string { return $this->name; }
    public function getAge(): int     { return $this->age; }

    // ---- setters with rules ----
    public function setName(string $name): void {
        $name = trim($name);
        if ($name === "") {
            die("Name cannot be empty.");
        }
        $this->name = $name;
    }

    public function setAge(int $age): void {
        if ($age < 15 || $age > 90) {
            die("Age must be between 15 and 90.");
        }
        $this->age = $age;
    }
}

$s = new Student("Chanda", 21);
echo $s->getName() . " is " . $s->getAge();

$s->setAge(250);   // the setter's rule blocks nonsense

Read-only properties — set once, never change

Some things should never change after creation — a student number, an invoice number, a date of birth. Modern PHP has a keyword for exactly that:

class Student {
    public function __construct(
        public readonly string $studentNumber,   // set once at birth, frozen forever
        public string $name
    ) {}
}

$s = new Student("LGU2026-001", "Chanda");
echo $s->studentNumber;         // reading is fine
$s->name = "Chanda Mwila";      // normal property, fine
$s->studentNumber = "HACKED";   // 💥 Error: Cannot modify readonly property

readonly gives you the safety of private-with-a-getter but with less typing: publicly readable, never writable after the constructor.

<?php
class Fridge {
    private int $temperature = 4;

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

    public function setTemperature(int $t): void {
        if ($t < 1 || $t > 8) {
            echo "Unsafe temperature!<br>";
            return;
        }
        $this->temperature = $t;
    }
}

$f = new Fridge();
$f->setTemperature(6);
echo $f->getTemperature() . "<br>";   // 6
$f->setTemperature(20);                 // Unsafe temperature!
echo $f->getTemperature();              // still 6 — protected!