Особенности статических классов в PHP (статический класс)

Расширенные примеры статических классов в PHP

Пример 1: Статический класс для работы с кэшем (с конфигурацией)

<?php
class Cache {
    private static array $store = [];
    private static int $ttl = 3600; // время жизни по умолчанию

    private function __construct() {}

    public static function setTtl(int $seconds): void {
        self::$ttl = $seconds;
    }

    public static function set(string $key, mixed $value, ?int $ttl = null): void {
        $expire = time() + ($ttl ?? self::$ttl);
        self::$store[$key] = ['value' => $value, 'expire' => $expire];
    }

    public static function get(string $key): mixed {
        if (!isset(self::$store[$key])) {
            return null;
        }
        $data = self::$store[$key];
        if (time() > $data['expire']) {
            unset(self::$store[$key]);
            return null;
        }
        return $data['value'];
    }

    public static function flush(): void {
        self::$store = [];
    }
}

// Использование
Cache::set('user_1', ['name' => 'Alice']);
Cache::setTtl(60);
$user = Cache::get('user_1');
var_dump($user);
// array(1) { ["name"]=> string(5) "Alice" }
?>

Пояснение: статический класс Cache хранит данные в статическом массиве. Метод setTtl меняет время жизни по умолчанию. Все методы статические, конструктор приватный - экземпляр создать нельзя.

Пример 2: Статический трейт с общей функциональностью

<?php
trait SingletonTrait {
    private static ?self $instance = null;

    private function __construct() {}
    private function __clone() {}
    private function __wakeup() {}

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

class Database {
    use SingletonTrait;

    public function query(string $sql): array {
        // эмуляция
        return ['result' => $sql];
    }
}

$db = Database::getInstance();
var_dump($db->query('SELECT 1'));
?>

array(1) {
  ["result"]=>
  string(8) "SELECT 1"
}

Пояснение: трейт реализует синглтон. Класс Database использует его и получает единственный экземпляр. Трейт можно переиспользовать в любом классе.

Пример 3: Позднее связывание в статической фабрике

<?php
abstract class Animal {
    abstract protected static function getSound(): string;

    public static function speak(): void {
        echo static::getSound() . PHP_EOL;
    }
}

class Dog extends Animal {
    protected static function getSound(): string {
        return 'Woof!';
    }
}

class Cat extends Animal {
    protected static function getSound(): string {
        return 'Meow!';
    }
}

Dog::speak(); // Woof!
Cat::speak(); // Meow!
?>

Woof!
Meow!

Пояснение: абстрактный статический метод getSound определён в наследниках. Метод speak() использует static:: для вызова реализации конкретного класса. Это позволяет строить иерархии с полиморфизмом на уровне классов.

Пример 4: Статический класс с константами и неизменяемыми настройками

<?php
class AppConfig {
    private function __construct() {}

    public const APP_NAME = 'MyApp';
    public const VERSION = '1.0.0';
    private const SECRET_KEY = 's3cr3t';

    public static function getSecret(): string {
        return self::SECRET_KEY;
    }

    public static function isDebug(): bool {
        return defined('DEBUG') && DEBUG === true;
    }
}

// Использование
echo AppConfig::APP_NAME; // MyApp
echo AppConfig::getSecret(); // s3cr3t
?>

Пояснение: класс предоставляет доступ к конфигурационным константам. Приватная константа доступна только через статический метод. Конструктор приватный - инстанцирование запрещено.

Пример 5: Утилитарный класс для валидации (с проблемами статического состояния)

<?php
class Validator {
    private static array $errors = [];

    public static function validateEmail(string $email): bool {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            self::$errors[] = 'Invalid email';
            return false;
        }
        return true;
    }

    public static function getErrors(): array {
        return self::$errors;
    }

    public static function clearErrors(): void {
        self::$errors = [];
    }
}

Validator::validateEmail('test@');
Validator::validateEmail('user@example.com');
print_r(Validator::getErrors());
// Array ( [0] => Invalid email )
?>

Array
(
    [0] => Invalid email
)

Проблема: статический массив $errors накапливает ошибки между вызовами. Если не вызвать clearErrors(), предыдущие ошибки останутся. Это типичный недостаток статического состояния - его сложно сбросить и тестировать.

Решение: либо передавать массив ошибок по ссылке, либо использовать экземпляр класса вместо статического.

Пример 6: Использование статического класса как реестра (Registry)

<?php
class Registry {
    private static array $services = [];

    private function __construct() {}

    public static function set(string $key, object $service): void {
        self::$services[$key] = $service;
    }

    public static function get(string $key): ?object {
        return self::$services[$key] ?? null;
    }

    public static function has(string $key): bool {
        return isset(self::$services[$key]);
    }
}

// Регистрация сервисов
Registry::set('db', new Database());
Registry::set('logger', new Logger());

// Получение
$db = Registry::get('db');
?>

Пояснение: реестр хранит объекты в статическом массиве. Это упрощает доступ к глобальным сервисам, но создаёт те же проблемы, что и синглтон - глобальное состояние.