PHP: полный мануал с примерами, функциями и ООП

<?php
declare(strict_types=1);

class OrderNumber
{
    public static function format(int $id): string
    {
        return 'ORD-' . $id;
    }
}
echo OrderNumber::format(42), "\n";

ORD-42

static у метода разрешает вызов без экземпляра. :: выбирает член класса; -> обращается к члену объекта. В этом методе нет $this: никакой текущий заказ ему не передан. Та же операция могла бы быть функцией formatOrderNumber(42).

<?php
declare(strict_types=1);

class NumberLabel
{
    protected const PREFIX = 'ITEM';
    public static function fixed(int $id): string { return self::PREFIX . '-' . $id; }
    public static function flexible(int $id): string { return static::PREFIX . '-' . $id; }
}
class OrderLabel extends NumberLabel
{
    protected const PREFIX = 'ORD';
}
echo OrderLabel::fixed(42), "\n";
echo OrderLabel::flexible(42), "\n";

ITEM-42
ORD-42

Оба тела объявлены в NumberLabel. self::PREFIX берёт его константу. static::PREFIX учитывает, что исходный вызов был OrderLabel::flexible, и берёт ORD. Это позднее статическое связывание; оно нужно здесь ради общей операции с разными метаданными потомков.

<?php
declare(strict_types=1);

class Identifier
{
    final public function __construct(public readonly int $value)
    {
        if ($value < 1) { throw new InvalidArgumentException('Номер должен быть положительным'); }
    }
    public static function fromInt(int $value): static { return new static($value); }
}
class OrderId extends Identifier {}
class ProductId extends Identifier {}
$order = OrderId::fromInt(42);
$product = ProductId::fromInt(7);
echo 'Заказ ', $order->value, ' (', get_class($order), ")\n";
echo 'Товар ', $product->value, ' (', get_class($product), ")\n";

Заказ 42 (OrderId)
Товар 7 (ProductId)

new static создаёт вызванный класс. : static обещает соответствующий тип результата. final-конструктор сохраняет единый набор аргументов: потомок не может внезапно потребовать другое обязательное значение. Если расширение не нужно, final-класс и new self проще.

<?php
declare(strict_types=1);

class PriceLabel
{
    public static string $currency = 'RUB';
    public function format(int $kopecks): string { return $kopecks . ' ' . self::$currency; }
}
$first = new PriceLabel();
$second = new PriceLabel();
echo $first->format(25900), "\n";
PriceLabel::$currency = 'коп.';
echo $first->format(25900), "\n";
echo $second->format(25900), "\n";

25900 RUB
25900 коп.
25900 коп.

Изменение видно всем экземплярам, поэтому такая переменная плохо подходит отдельной валюте магазина. RUB в первой строке намеренно показывает ошибочную подпись: число всё ещё в копейках. Настройки единиц лучше согласованно хранить в каждом объекте или передавать в функцию.

<?php
declare(strict_types=1);

$labels = array_map(static fn(int $id): string => 'ORD-' . $id, [42, 43]);
echo implode(', ', $labels), "\n";

ORD-42, ORD-43

array_map вызывает callback для каждого номера. fn создаёт короткую функцию-значение; static исключает автоматическую привязку $this. Явно использованные внешние значения всё равно могут захватываться по правилам замыканий. Это отдельная возможность, не статическое поле класса.

<?php
declare(strict_types=1);

class OrderExport
{
    final public const string SCHEMA = 'orders-v1';
    protected const string SEPARATOR = ';';

    public static function header(): string
    {
        return self::SCHEMA . self::SEPARATOR . 'id';
    }
}

$selected = 'SCHEMA';
echo OrderExport::SCHEMA, "\n";
echo OrderExport::{$selected}, "\n";
echo OrderExport::header(), "\n";

orders-v1
orders-v1
orders-v1;id

String у константы и динамическое ::{$selected} доступны с PHP 8.3. Final у констант — с PHP 8.1: потомок не сможет незаметно назвать другую схему тем же SCHEMA. Protected прячет внутренний разделитель от внешнего вызова.

<?php
declare(strict_types=1);

class BaseReport
{
    public static function prefix(): string { return 'База'; }
    public static function header(): string { return static::prefix(); }
}

class ReportFamily extends BaseReport
{
    public static function variants(): array
    {
        return [BaseReport::header(), parent::header(), self::header(), static::header()];
    }
}

class SpecialReport extends ReportFamily
{
    public static function prefix(): string { return 'Специальный'; }
}

echo implode(', ', SpecialReport::variants()), "\n";

База, Специальный, Специальный, Специальный

Parent выбирает реализацию метода родителя, но сохраняет вызванный класс SpecialReport для последующего static внутри header. Self выбирает область ReportFamily с тем же сохранением контекста. Явный BaseReport::header фиксирует новую точку вызова BaseReport.

<?php
declare(strict_types=1);

class BaseCaption
{
    private function token(): string { return 'Базовая подпись'; }
    public function owned(): string { return $this->token(); }
    public function late(): string { return static::token(); }
}

class CustomCaption extends BaseCaption
{
    private function token(): string { return 'Закрытая подпись потомка'; }
}

$caption = new CustomCaption();
echo $caption->owned(), "\n";
try {
    echo $caption->late(), "\n";
} catch (Error $error) {
    echo "Родитель не получил доступ к private потомка\n";
}

Базовая подпись
Родитель не получил доступ к private потомка

Owned исполняется в области BaseCaption и вызывает его закрытую реализацию. Static в late пытается разрешить метод через фактически вызванный CustomCaption, но тот token закрыт для области родителя. Late binding меняет разрешение, а не права доступа.