Chapter 09 · Going Deeper

Static & Constants

Everything so far belonged to individual objects — each cookie carried its own data. But some things logically belong to the cutter itself: a counter of how many cookies were made, a shared setting, a utility calculation. That's what static is for.

Static properties — one shared value

<?php
class Student {
    public static int $count = 0;        // the shared noticeboard

    public function __construct(public string $name) {
        self::$count++;                  // every new student updates the shared counter
    }
}

new Student("Chanda");
new Student("Mutinta");
new Student("Bwalya");

echo "Students registered: " . Student::$count;

Two brand-new symbols:

• :: — the double colon (officially the "scope resolution operator"). It accesses things on a class, the way -> accesses things on an object. Student::$count = "the Student class's count".
• self:: — used inside a class to refer to the class itself, the way $this refers to the current object. self::$count = "my class's count".

Static methods — skills that need no object

A static method belongs to the class and is called without creating any object. Perfect for utility work that doesn't depend on any particular object's data:

class Fees {
    public static function withVat(float $amount): float {
        return round($amount * 1.16, 2);
    }

    public static function format(float $amount): string {
        return "K" . number_format($amount, 2);
    }
}

// No "new" anywhere — call directly on the class:
echo Fees::format(Fees::withVat(5000));

Class constants — values carved in stone

Constants are values that never change — no $, written in CAPITALS by convention, accessed with :::

class Grade {
    const PASS_MARK   = 50;
    const DISTINCTION = 75;

    public static function of(int $marks): string {
        if ($marks >= self::DISTINCTION) return "Distinction";
        if ($marks >= self::PASS_MARK)   return "Pass";
        return "Fail";
    }
}

echo "Pass mark is " . Grade::PASS_MARK . "<br>";
echo "67 => " . Grade::of(67);

Why constants instead of plain numbers scattered in the code? Because Grade::PASS_MARK explains itself, lives in exactly one place, and if the university senate changes the pass mark to 45, you edit one line and the whole system follows. Numbers sprinkled through code ("magic numbers") are a maintenance nightmare.

A realistic combined example

class StudentNumber {
    const PREFIX = "LGU";
    private static int $lastSerial = 0;

    public static function generate(int $year): string {
        self::$lastSerial++;
        // str_pad turns 7 into "007"
        return self::PREFIX . $year . "-" . str_pad(self::$lastSerial, 3, "0", STR_PAD_LEFT);
    }
}

echo StudentNumber::generate(2026) . "<br>";
echo StudentNumber::generate(2026) . "<br>";
echo StudentNumber::generate(2026);

A shared constant, a shared private counter, a public static generator — no objects needed. This is exactly how real systems mint sequential IDs, invoice numbers and receipt numbers.

When to use static — and when not to

• ✅ Counters and shared state that genuinely belongs to the whole class.
• ✅ Pure utility/helper calculations (formatting, converting, validating).
• ✅ Constants for fixed configuration values.
• ❌ Don't make everything static "because it's easier" — you lose the entire benefit of objects (separate data, polymorphism, testability). If in doubt, prefer normal objects.

<?php
class Converter {
    const KWACHA_PER_DOLLAR = 27.5;

    public static function toKwacha(float $usd): float {
        return round($usd * self::KWACHA_PER_DOLLAR, 2);
    }

    public static function toDollars(float $zmw): float {
        return round($zmw / self::KWACHA_PER_DOLLAR, 2);
    }
}

echo "$100 = K" . Converter::toKwacha(100) . "<br>";
echo "K550 = $" . Converter::toDollars(550);