Static Methods and Properties in PHP — When, Why, and How to Use Them

<?php

class PageVisitCounter
{
    // This property belongs to the CLASS, not to any single object.
    // All instances share this one value.
    private static int $totalVisits = 0;

    // A regular instance property — each object gets its own copy.
    private string $pageName;

    public function __construct(string $pageName)
    {
        $this->pageName = $pageName;

        // Every time any page object is created, the shared counter increments.
        self::$totalVisits++;
    }

    // Static method — no $this, because no specific object is needed.
    public static function getTotalVisits(): int
    {
        return self::$totalVisits;
    }

    // Regular instance method — tied to THIS specific page object.
    public function getPageName(): string
    {
        return $this->pageName;
    }
}

// Three separate page objects are created...
$homepage   = new PageVisitCounter('Home');
$aboutPage  = new PageVisitCounter('About');
$contactPage = new PageVisitCounter('Contact');

// ...but there is only ONE shared counter across all of them.
echo PageVisitCounter::getTotalVisits() . PHP_EOL; // 3

// You can also call it via an instance — PHP allows this, but it's misleading style.
// Prefer the class-name syntax above to signal it's static.
echo $homepage->getTotalVisits() . PHP_EOL; // Still 3 — same counter

echo $homepage->getPageName() . PHP_EOL;   // Home
echo $aboutPage->getPageName() . PHP_EOL;  // About

<?php

class BaseModel
{
    protected string $type;

    public function __construct()
    {
        // get_class($this) shows us which class was actually instantiated.
        $this->type = get_class($this);
    }

    // BAD version — uses self:: which is locked to BaseModel at compile time.
    public static function createWithSelf(): static
    {
        return new self(); // Always creates a BaseModel, even when called on a child!
    }

    // GOOD version — uses static:: which resolves to the calling class at runtime.
    public static function createWithStatic(): static
    {
        return new static(); // Creates whichever class actually called this method.
    }

    public function getType(): string
    {
        return $this->type;
    }
}

class UserModel extends BaseModel
{
    public function fetchPermissions(): string
    {
        return "Fetching permissions for a {$this->type}";
    }
}

// --- Demonstrating the difference ---

$selfResult   = UserModel::createWithSelf();   // Calls BaseModel::createWithSelf()
$staticResult = UserModel::createWithStatic(); // Calls BaseModel::createWithStatic()

echo $selfResult->getType() . PHP_EOL;   // BaseModel — WRONG! We called UserModel.
echo $staticResult->getType() . PHP_EOL; // UserModel  — Correct.

// This will cause a fatal error because $selfResult is a BaseModel, not a UserModel.
// Uncomment to see: echo $selfResult->fetchPermissions();

// This works perfectly because $staticResult IS a UserModel.
echo $staticResult->fetchPermissions() . PHP_EOL;

<?php

/**
 * Money value object demonstrating static factory methods.
 * Multiple ways to construct — all clear, all explicit.
 */
class Money
{
    // Private constructor forces callers to use the named factory methods.
    // This prevents ambiguous construction like: new Money(150, 'cents') vs new Money(1.50, 'dollars')
    private function __construct(
        private readonly int    $amountInCents,
        private readonly string $currencyCode
    ) {}

    // Factory method 1: construct from an integer number of cents.
    public static function fromCents(int $cents, string $currency = 'USD'): self
    {
        // Validate here before the object is even created — impossible in a single constructor.
        if ($cents < 0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
        return new self($cents, strtoupper($currency));
    }

    // Factory method 2: construct from a float (handles the cents conversion internally).
    public static function fromFloat(float $amount, string $currency = 'USD'): self
    {
        if ($amount < 0.0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
        // Round to avoid floating-point dust (e.g., 1.005 * 100 = 100.4999...)
        $cents = (int) round($amount * 100);
        return new self($cents, strtoupper($currency));
    }

    // Factory method 3: construct from a formatted string like "$9.99".
    public static function fromFormattedString(string $formattedAmount, string $currency = 'USD'): self
    {
        // Strip currency symbols and whitespace before parsing.
        $cleaned = preg_replace('/[^0-9.]/', '', $formattedAmount);
        return self::fromFloat((float) $cleaned, $currency);
    }

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

    public function format(): string
    {
        return sprintf('%s %.2f', $this->currencyCode, $this->amountInCents / 100);
    }

    // A pure utility — doesn't need instance state, belongs to the concept of Money.
    public static function zero(string $currency = 'USD'): self
    {
        return new self(0, strtoupper($currency));
    }
}

// --- Three crystal-clear ways to create Money objects ---

$productPrice   = Money::fromCents(1999);             // $19.99 from a database integer
$shippingFee    = Money::fromFloat(4.99);              // $4.99 from user input
$discountAmount = Money::fromFormattedString('$2.50'); // $2.50 from a config file
$emptyWallet    = Money::zero();

echo $productPrice->format()   . PHP_EOL;
echo $shippingFee->format()    . PHP_EOL;
echo $discountAmount->format() . PHP_EOL;
echo $emptyWallet->format()    . PHP_EOL;

echo 'Product in cents: ' . $productPrice->getAmountInCents() . PHP_EOL;

<?php

/**
 * A utility class whose methods are genuinely context-free.
 * These are good static candidates — they take input, return output,
 * hold no state, and never need to be swapped for a test double.
 */
class StringHelper
{
    // Pure function: same input always gives same output, no side effects.
    public static function toTitleCase(string $sentence): string
    {
        // ucwords converts first letter of each word to uppercase.
        return ucwords(strtolower(trim($sentence)));
    }

    // Pure function: strips non-alphanumeric characters for use in URLs.
    public static function toSlug(string $title): string
    {
        $lowercased  = strtolower(trim($title));
        $spaceless   = preg_replace('/[\s_]+/', '-', $lowercased);  // spaces and underscores become hyphens
        $clean       = preg_replace('/[^a-z0-9\-]/', '', $spaceless); // strip everything else
        return rtrim($clean, '-'); // remove any trailing hyphens
    }

    // Pure function: truncates a string and appends ellipsis if needed.
    public static function truncate(string $text, int $maxLength = 100, string $suffix = '...'): string
    {
        if (mb_strlen($text) <= $maxLength) {
            return $text; // Already short enough — return as-is.
        }

        // Cut at a word boundary so we don't slice mid-word.
        $truncated = mb_substr($text, 0, $maxLength);
        $lastSpace = mb_strrpos($truncated, ' ');

        return ($lastSpace !== false)
            ? mb_substr($truncated, 0, $lastSpace) . $suffix
            : $truncated . $suffix;
    }
}

// These static calls are totally fine — no hidden state, fully testable as pure functions.
$articleTitle   = StringHelper::toTitleCase('  the QUICK brown FOX  ');
$urlSlug        = StringHelper::toSlug('The Quick Brown Fox! (2024)');
$previewText    = StringHelper::truncate(
    'Static methods in PHP can be extremely useful when applied thoughtfully to the right problems.',
    50
);

echo $articleTitle . PHP_EOL;
echo $urlSlug      . PHP_EOL;
echo $previewText  . PHP_EOL;