ООП в PHP – руководство с примерами
ООП в PHP объединяет данные и операции над ними в объекты. Класс описывает свойства и методы, а оператор new создает экземпляр класса. Вы научитесь ограничивать доступ к данным, использовать интерфейсы и подключать автозагрузку. Рабочие примеры помогут постепенно перевести процедурный скрипт на классы.
- Что такое ООП в PHP
- Классы и объекты: первый класс на PHP
- Свойства и методы
- Конструктор и деструктор
- Модификаторы доступа и инкапсуляция
- Наследование
- Абстрактные классы и интерфейсы
- Полиморфизм на примере
- Трейты
- Статические свойства и методы
- Магические методы
- Перечисления (enum)
- Пространства имен и автозагрузка
- Как перевести процедурный код на ООП
- Ошибки при переходе на ООП в PHP
Что такое ООП в PHP
Объектно-ориентированное программирование организует код вокруг объектов с определенными обязанностями. Например, корзина хранит позиции и рассчитывает стоимость заказа. Свойства содержат состояние объекта, методы читают или изменяют его.
Класс задает структуру и поведение своих экземпляров. Два объекта одного класса могут хранить разные значения свойств. Изменение одного экземпляра обычно не затрагивает другой. Исключения возникают, когда объекты используют общее изменяемое состояние.
Инкапсуляция защищает правила изменения состояния через ограничения доступа. Наследование расширяет поведение родительского класса в дочернем. Полиморфизм позволяет вызывать общий контракт у разных реализаций интерфейса. Абстракция выделяет нужные операции и скрывает подробности реализации, в том числе через абстрактные классы.
ООП помогает разделять ответственность между частями растущего приложения. Для короткого преобразования массива отдельный класс может быть лишним. Полный синтаксис описывает руководство PHP «Классы и объекты».
Классы и объекты: первый класс на PHP
Ключевое слово class объявляет класс, а new создает объект. Оператор -> обращается к свойствам и методам экземпляра.
Внутри нестатического метода переменная $this обозначает текущий объект.
Схема показывает связь класса и экземпляров через план дома. Один план задает общую структуру нескольких отдельных построек.
Для выполнения примеров понадобится установленный PHP с командным интерпретатором. Сохраните каждый самостоятельный листинг в отдельный файл example.php. Затем запустите файл из терминала в его каталоге:
php -v
php example.phpПервая команда показывает установленную версию, вторая выполняет скрипт. Основные примеры требуют PHP 8.2 или новее из-за readonly-классов. Для отдельных возможностей PHP 8.4 указаны дополнительные требования.
Если вы используете Docker, получите обновленный образ ветки PHP 8. Команда с PHP_VERSION покажет точную версию интерпретатора внутри контейнера.
docker pull php:8-cli
mkdir php-oop
cd php-oop
docker run --rm php:8-cli php -r 'echo PHP_VERSION, PHP_EOL;'Сохраните example.php в созданный каталог php-oop. В терминале Bash запустите его через контейнер следующей командой:
docker run --rm -v "$PWD":/app -w /app php:8-cli php example.phpНе объединяйте все листинги в один файл. Некоторые примеры повторно объявляют классы с одинаковыми именами.
<?php
declare(strict_types=1);
class Product
{
public string $name = 'Книга';
public function label(): string
{
return $this->name;
}
}
$first = new Product();
$second = new Product();
$second->name = 'Тетрадь';
echo $first->label(), PHP_EOL;
echo $second->label(), PHP_EOL;
var_dump($first instanceof Product);
var_dump($first === $second);
var_dump(get_object_vars($first));Скрипт создаст 2 независимых экземпляра и покажет их различия:
Книга
Тетрадь
bool(true)
bool(false)
array(1) {
["name"]=>
string(10) "Книга"
}Длина строки указана для файла в кодировке UTF-8. Функция var_dump() показывает типы и значения выражений. Если передать ей сам объект, вывод дополнительно покажет его идентификатор. Этот идентификатор зависит от конкретного запуска.
Присваивание $copy = $first не создает независимую копию. Обе переменные будут указывать на один объект.
Оператор clone создает поверхностную копию экземпляра.
Свойства и методы
Свойство хранит данные объекта, метод выполняет операцию над ними. Типизированные свойства появились в PHP 7.4. Запись ?string разрешает строку или значение null.
<?php
declare(strict_types=1);
class Customer
{
public string $name = 'Гость';
public ?string $email = null;
public int $orders = 0;
public function rename(string $name): void
{
$this->name = $name;
}
public function contact(): string
{
return $this->email ?? 'Email не указан';
}
public function hasOrders(): bool
{
return $this->orders > 0;
}
}
$customer = new Customer();
$customer->rename('Анна');
echo $customer->name, PHP_EOL;
echo $customer->contact(), PHP_EOL;
var_dump($customer->hasOrders());Анна
Email не указан
bool(false)Тип после двоеточия описывает результат метода.
Метод с типом void не возвращает значение. В примере rename() меняет состояние, а contact() возвращает строку.
Типизированное свойство без начального значения остается неинициализированным. Чтение такого свойства вызывает Error, даже при nullable-типе. Объявление public ?string $email; само не присваивает null.
Не создавайте свойства случайным присваиванием неизвестному имени. PHP 8.2 помечает создание динамических свойств как устаревшее поведение. Объявляйте ожидаемые свойства в классе, чтобы опечатки обнаруживались раньше.
Конструктор и деструктор
Конструктор получает начальные данные при создании экземпляра. Деструктор выполняет завершающие действия при уничтожении объекта. Эти методы решают разные задачи и не заменяют друг друга.
Как написать __construct
Метод __construct() вызывается при выполнении new.
У конструктора не указывают возвращаемый тип.
<?php
declare(strict_types=1);
class Product
{
private string $name;
public function __construct(string $name)
{
$this->name = $name;
}
public function name(): string
{
return $this->name;
}
}
echo (new Product('Книга'))->name(), PHP_EOL;КнигаConstructor promotion и readonly
Constructor promotion появился в PHP 8.0 и сокращает объявления свойств. Модификатор доступа перед параметром одновременно объявляет свойство и присваивает значение. Readonly-свойства появились в PHP 8.1, readonly-классы – в PHP 8.2.
<?php
declare(strict_types=1);
class Product
{
public function __construct(
public readonly string $name,
private int $price
) {
if ($price < 0) {
throw new InvalidArgumentException('Цена не может быть отрицательной');
}
}
public function price(): int
{
return $this->price;
}
}
readonly class Address
{
public function __construct(
public string $city,
public string $street
) {}
}
$product = new Product('Книга', 500);
$address = new Address('Казань', 'Центральная');
echo $product->name, ': ', $product->price(), PHP_EOL;
echo $address->city, ', ', $address->street, PHP_EOL;
try {
$product->name = 'Альбом';
} catch (Error $error) {
echo 'Изменение readonly запрещено', PHP_EOL;
}Книга: 500
Казань, Центральная
Изменение readonly запрещеноReadonly-свойство допускает инициализацию, но запрещает обычное последующее присваивание. В readonly-классе этот режим действует для всех объявленных свойств.
Такие свойства должны иметь тип; статические свойства использовать нельзя.
Readonly не делает вложенный объект неизменяемым.
Если свойство хранит объект, его внутреннее состояние может меняться. Ограничение защищает само свойство от замены значения.
Когда PHP вызывает __destruct
Метод __destruct() вызывается, когда объект больше не удерживают ссылки. Для оставшихся объектов PHP обычно вызывает деструкторы при завершении скрипта. Циклические ссылки могут отложить уничтожение до сборки мусора.
<?php
class Lifetime
{
public function __destruct()
{
echo 'Объект уничтожен', PHP_EOL;
}
}
$first = new Lifetime();
$second = $first;
unset($first);
echo 'Вторая переменная удерживает объект', PHP_EOL;
unset($second);
echo 'Скрипт продолжает работу', PHP_EOL;Вторая переменная удерживает объект
Объект уничтожен
Скрипт продолжает работуНе поручайте деструктору оплату заказа или критичную запись данных. Аварийное завершение процесса не гарантирует выполнение завершающего кода. Освобождайте важные ресурсы явно, при необходимости через try/finally.
Модификаторы доступа и инкапсуляция
Модификаторы доступа определяют, откуда можно обращаться к членам класса. Инкапсуляция помогает сохранить правила изменения состояния объекта. Например, цена товара не должна становиться отрицательной.
| Модификатор | Внутри объявившего класса | В связанных наследованием классах | Снаружи |
|---|---|---|---|
| public | Да | Да | Да |
| protected | Да | Да | Нет |
| private | Да | Нет, напрямую недоступно | Нет |
Метод без модификатора доступа по умолчанию получает public.
Для обычного свойства пишите модификатор явно. Историческая запись var $name тоже объявляет публичное свойство.
<?php
declare(strict_types=1);
class Product
{
private int $price = 0;
protected string $currency = 'RUB';
public function getPrice(): int
{
return $this->price;
}
public function setPrice(int $price): void
{
if ($price < 0) {
throw new InvalidArgumentException('Отрицательная цена');
}
$this->price = $price;
}
public function label(): string
{
return $this->price . ' ' . $this->currency;
}
}
$product = new Product();
$product->setPrice(500);
echo $product->label(), PHP_EOL;
try {
$product->setPrice(-1);
} catch (InvalidArgumentException $error) {
echo $error->getMessage(), PHP_EOL;
}
echo $product->getPrice(), PHP_EOL;500 RUB
Отрицательная цена
500Геттер возвращает значение, а сеттер управляет его изменением. Не создавайте сеттер автоматически для каждого закрытого свойства. Методы addItem() или changePassword() лучше выражают действие предметной области.
Property hooks и асимметричная видимость в PHP 8.4
PHP 8.4 добавил хуки свойств и раздельную видимость чтения и записи. Хуки get и set выполняют код при обращении к свойству. Запись public private(set) разрешает внешнее чтение, но ограничивает запись классом.
Сохраните этот пример отдельно и запускайте на PHP 8.4 или новее:
<?php
declare(strict_types=1);
class Stock
{
public private(set) int $reserved = 0;
public int $available = 0 {
set {
if ($value < 0) {
throw new InvalidArgumentException('Отрицательный остаток');
}
$this->available = $value;
}
}
public function reserve(): void
{
if ($this->available === 0) {
throw new LogicException('Нет товара');
}
$this->available--;
$this->reserved++;
}
}
$stock = new Stock();
$stock->available = 3;
$stock->reserve();
echo $stock->available, '/', $stock->reserved, PHP_EOL;
try {
$stock->reserved = 10;
} catch (Error $error) {
echo 'Внешняя запись запрещена', PHP_EOL;
}2/1
Внешняя запись запрещенаПример использует хук set для проверки остатка. Обращение к этому же свойству внутри хука работает с хранимым значением.
Хук get также может вычислять результат без хранения отдельного значения.
Наследование
Оператор extends связывает дочерний класс с родительским. PHP разрешает наследование только от одного класса. Дочерний класс может переопределять доступные методы, сохраняя совместимую сигнатуру.
<?php
declare(strict_types=1);
class Message
{
public function __construct(protected string $text) {}
public function render(): string
{
return $this->text;
}
final public function type(): string
{
return 'message';
}
}
final class Alert extends Message
{
public function __construct(string $text, private string $level)
{
parent::__construct($text);
}
public function render(): string
{
return '[' . $this->level . '] ' . parent::render();
}
}
$alert = new Alert('Нет соединения', 'warning');
echo $alert->render(), PHP_EOL;
echo $alert->type(), PHP_EOL;[warning] Нет соединения
messageВызов parent::render() использует реализацию родителя. Если потомок объявил собственный конструктор, вызов родительского выполняют явно. Без собственного конструктора потомок наследует доступный конструктор родителя.
Модификатор final запрещает переопределение метода или наследование класса. В примере нельзя переопределить type() или унаследовать Alert.
Закрытое свойство родителя не становится доступным коду потомка.
Используйте наследование, когда потомок действительно подходит вместо родителя. Если объект просто использует чужие возможности, передайте зависимость в конструктор. Такая связь называется композицией.
Абстрактные классы и интерфейсы
Абстрактный класс объединяет общую реализацию и обязательные методы потомков. Интерфейс задает контракт, который реализуют разные классы. Оба механизма помогают отделить использование объекта от подробностей его устройства.
| Возможность | Абстрактный класс | Интерфейс |
|---|---|---|
| Создать экземпляр напрямую | Нельзя | Нельзя |
| Хранить состояние экземпляра | Можно | Не хранит состояние |
| Содержать реализацию методов | Можно | Нет |
| Модификаторы методов | public, protected, private | Публичные методы контракта |
| Сколько может использовать класс | Один родительский класс | Несколько интерфейсов |
| Обычный способ подключения | extends | implements |
Начиная с PHP 8.4 интерфейсы также могут задавать требования к свойствам. Это контракт доступа, который не выделяет место для хранения данных. Для базовых примеров достаточно контрактов методов.
<?php
declare(strict_types=1);
interface Renderable
{
public function render(): string;
}
interface Identifiable
{
public function id(): int;
}
abstract class Document
{
public function __construct(protected string $title) {}
public function heading(): string
{
return 'Документ: ' . $this->title;
}
abstract public function render(): string;
}
class Invoice extends Document implements Renderable, Identifiable
{
public function id(): int
{
return 42;
}
public function render(): string
{
return $this->heading() . ' #' . $this->id();
}
}
echo (new Invoice('Счет'))->render(), PHP_EOL;Документ: Счет #42Абстрактный метод объявляют без тела, завершая строку точкой с запятой. Конкретный потомок обязан реализовать оставшиеся абстрактные методы.
Реализация интерфейса также должна соблюдать типы и видимость его методов.
Полиморфизм на примере
Полиморфизм позволяет функции работать с разными реализациями одного контракта. Укажите интерфейс в типе параметра вместо конкретного класса. Тогда функция не будет зависеть от выбранного способа выполнения операции.
<?php
declare(strict_types=1);
interface Formatter
{
public function format(string $text): string;
}
class PlainFormatter implements Formatter
{
public function format(string $text): string
{
return $text;
}
}
class JsonFormatter implements Formatter
{
public function format(string $text): string
{
return json_encode(
['message' => $text],
JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR
);
}
}
function printMessage(Formatter $formatter, string $text): void
{
echo $formatter->format($text), PHP_EOL;
}
printMessage(new PlainFormatter(), 'Заказ принят');
printMessage(new JsonFormatter(), 'Заказ принят');Заказ принят
{"message":"Заказ принят"}Функция printMessage() вызывает только метод, объявленный интерфейсом. Для добавления нового формата достаточно написать еще одну реализацию. Условие с проверкой конкретного класса функции не требуется.
Трейты
Трейт переносит реализацию методов в несколько классов без общего родителя. Объявите его через trait, затем подключите оператором use внутри класса.
Сам трейт нельзя создать через new.
<?php
trait FileLog
{
public function log(): string
{
return 'Запись в файл';
}
}
trait ConsoleLog
{
public function log(): string
{
return 'Запись в консоль';
}
}
class Report
{
use FileLog, ConsoleLog {
FileLog::log insteadof ConsoleLog;
ConsoleLog::log as consoleLog;
}
}
$report = new Report();
echo $report->log(), PHP_EOL;
echo $report->consoleLog(), PHP_EOL;Запись в файл
Запись в консольОператор insteadof выбирает метод при конфликте двух трейтов. Оператор as создает дополнительное имя метода или меняет его видимость. Сам по себе псевдоним не удаляет исходный метод.
Не превращайте трейт в хранилище скрытых зависимостей. Если методы требуют настроек, подключения или отдельного жизненного цикла, используйте объект-зависимость. Его проще передать в конструктор и заменить в тесте.
Статические свойства и методы
Статический член принадлежит классу и доступен без создания экземпляра. Для обращения к нему используют оператор ::.
В статическом методе нет переменной $this.
<?php
declare(strict_types=1);
class Counter
{
private static int $count = 0;
public static function next(): int
{
return ++self::$count;
}
}
class BaseLabel
{
protected static string $label = 'base';
public static function fixed(): string
{
return self::$label;
}
public static function late(): string
{
return static::$label;
}
}
class ChildLabel extends BaseLabel
{
protected static string $label = 'child';
}
echo Counter::next(), PHP_EOL;
echo Counter::next(), PHP_EOL;
echo ChildLabel::fixed(), PHP_EOL;
echo ChildLabel::late(), PHP_EOL;1
2
base
childВ примере self:: обращается к классу объявления метода. Конструкция static:: учитывает класс, через который произошел вызов. Этот механизм называется поздним статическим связыванием.
Счетчик хранит общее значение в пределах выполняющегося процесса. Он не заменяет базу данных или общий счетчик посетителей сайта. При новом запуске скрипта значение снова начнется с нуля.
Магические методы
PHP автоматически вызывает магические методы при определенных операциях с объектом. Их имена начинаются с двух подчеркиваний.
Сигнатуры таких методов должны соответствовать требованиям языка.
__toString()задает строковое представление экземпляра.__get()обрабатывает чтение недоступного или отсутствующего свойства.__set()обрабатывает запись в недоступное или отсутствующее свойство.__call()обрабатывает вызов недоступного метода объекта.__callStatic()обрабатывает недоступный статический вызов.__invoke()позволяет вызывать объект как функцию.
<?php
declare(strict_types=1);
class MagicBox
{
private array $data = [];
public function __set(string $name, mixed $value): void
{
$this->data[$name] = $value;
}
public function __get(string $name): mixed
{
return $this->data[$name] ?? null;
}
public function __toString(): string
{
return 'Коробка';
}
public function __call(string $name, array $arguments): mixed
{
if ($name === 'greet' && count($arguments) === 1) {
return 'Привет, ' . $arguments[0];
}
throw new BadMethodCallException('Неизвестный метод');
}
public static function __callStatic(string $name, array $arguments): mixed
{
if ($name === 'version' && $arguments === []) {
return 'v1';
}
throw new BadMethodCallException('Неизвестный статический метод');
}
public function __invoke(string $text): string
{
return '[' . $text . ']';
}
}
$box = new MagicBox();
$box->title = 'Заказ';
echo $box->title, PHP_EOL;
echo $box, PHP_EOL;
echo $box->greet('Анна'), PHP_EOL;
echo MagicBox::version(), PHP_EOL;
echo $box('готово'), PHP_EOL;Заказ
Коробка
Привет, Анна
v1
[готово]Присваивание title вызывает __set() и заполняет закрытый массив. Динамическое свойство самого объекта в этом примере не создается. Для корректной поддержки isset() и unset() существуют отдельные магические методы.
Руководство PHP называет такую обработку недоступных членов «перегрузкой».
Перегрузки методов по числу или типам аргументов, как в Java, PHP не поддерживает. Нельзя объявить два метода с одинаковым именем внутри класса. Используйте один метод с необязательными параметрами или вариативным параметром.
Предпочитайте явные методы, если их набор известен заранее. Магические вызовы сложнее обнаруживать при чтении и статическом анализе. Не скрывайте через __call() ошибки в названиях обычных методов.
Перечисления (enum)
Перечисление задает закрытый набор допустимых значений типа. PHP 8.1 добавил обычные и backed-перечисления. Backed enum связывает каждый вариант со строковым или целочисленным значением.
<?php
declare(strict_types=1);
enum Direction
{
case North;
case South;
}
enum OrderStatus: string
{
case New = 'new';
case Paid = 'paid';
case Cancelled = 'cancelled';
public function label(): string
{
return match ($this) {
self::New => 'Новый',
self::Paid => 'Оплачен',
self::Cancelled => 'Отменен',
};
}
}
function canShip(OrderStatus $status): bool
{
return $status === OrderStatus::Paid;
}
echo Direction::North->name, PHP_EOL;
$status = OrderStatus::from('paid');
echo $status->value, PHP_EOL;
echo $status->label(), PHP_EOL;
var_dump(canShip($status));
var_dump(OrderStatus::tryFrom('unknown'));North
paid
Оплачен
bool(true)
NULLОбычный enum предоставляет имена вариантов через свойство name. Backed enum дополнительно предоставляет value, from() и tryFrom().
Метод from() выбрасывает ValueError для неизвестного значения. Метод tryFrom() возвращает null.
Храните строковое значение в базе, а внутри приложения используйте enum. Тогда функция с параметром OrderStatus не примет произвольную строку. Не добавляйте константу для каждого нового написания одного статуса.
Пространства имен и автозагрузка
Пространства имен разделяют классы с одинаковыми короткими названиями. Объявление namespace задает пространство, а use импортирует имя. Здесь use находится вне класса и не подключает трейт.
Composer генерирует автозагрузчик по правилам проекта. Стандарт PSR-4 связывает префикс пространства имен с базовым каталогом. Правило задается в секции autoload файла composer.json.
- Создайте отдельный каталог проекта и вложенный каталог
src/Shop. - Сохраните конфигурацию в корневой файл
composer.json. - Поместите класс в файл
src/Shop/Product.php. - Создайте точку входа
index.phpв корне проекта. - Запустите генерацию автозагрузчика и затем выполните точку входа.
Структура проекта до генерации автозагрузчика:
project/
composer.json
index.php
src/
Shop/
Product.phpФайл composer.json содержит соответствие префикса App\ каталогу src/:
{
"autoload": {
"psr-4": {
"App\\": "src/"
}
}
}Содержимое src/Shop/Product.php:
<?php
declare(strict_types=1);
namespace App\Shop;
final class Product
{
public function __construct(public readonly string $name) {}
}Содержимое корневого файла index.php:
<?php
declare(strict_types=1);
use App\Shop\Product;
require __DIR__ . '/vendor/autoload.php';
$product = new Product('Книга');
echo $product->name, PHP_EOL;При установленном Composer выполните команды из корня проекта:
composer --version
composer dump-autoload
php index.phpПервая команда покажет версию Composer. Вторая создаст каталог vendor с автозагрузчиком. Последняя команда выведет название товара:
КнигаЕсли Composer установлен локально как composer.phar, используйте php composer.phar dump-autoload. При добавлении зависимостей команда composer install также генерирует автозагрузчик.
Префикс PSR-4 заканчивается обратной косой чертой. В JSON обратную косую черту экранируют еще одной. После префикса App\ имя Shop\Product соответствует пути Shop/Product.php.
Регистр каталогов, файла и имени класса должен совпадать.
Импорт use сам по себе не загружает файл. Автозагрузчик срабатывает при обращении к еще не загруженному классу. Если меняете конфигурацию autoload, повторно выполните composer dump-autoload.
Как перевести процедурный код на ООП
Начните с небольшого участка, у которого понятен результат. Сохраните исходный расчет и перенесите его без изменения поведения. Для примера корзина содержит книгу и две тетради.
Процедурный расчет корзины
Скрипт хранит позиции в массиве и складывает их стоимость. Цены указаны в копейках, чтобы избежать дробной арифметики денег.
<?php
declare(strict_types=1);
$items = [
['name' => 'Книга', 'price' => 50000, 'quantity' => 1],
['name' => 'Тетрадь', 'price' => 10000, 'quantity' => 2],
];
$total = 0;
foreach ($items as $item) {
$total += $item['price'] * $item['quantity'];
}
echo $total, ' коп.', PHP_EOL;70000 коп.Выделение состояния и обязанностей
Позиция корзины отвечает за товар, количество и стоимость строки. Корзина хранит позиции и суммирует их результаты.
Вывод остается снаружи, поэтому расчет не зависит от HTML или терминала.
- Перенесите данные одной позиции в класс
CartItem. - Добавьте в конструктор исключение для отрицательной цены и количества меньше единицы.
- Перенесите умножение цены на количество в метод
subtotal(). - Создайте класс
Cartс закрытым массивом позиций. - Добавьте позиции через
add()и сравните итог с исходным скриптом.
<?php
declare(strict_types=1);
final readonly class CartItem
{
public function __construct(
public string $name,
public int $price,
public int $quantity
) {
if ($price < 0 || $quantity < 1) {
throw new InvalidArgumentException('Некорректная позиция');
}
}
public function subtotal(): int
{
return $this->price * $this->quantity;
}
}
final class Cart
{
/** @var list<CartItem> */
private array $items = [];
public function add(CartItem $item): void
{
$this->items[] = $item;
}
public function total(): int
{
$total = 0;
foreach ($this->items as $item) {
$total += $item->subtotal();
}
return $total;
}
}
$cart = new Cart();
$cart->add(new CartItem('Книга', 50000, 1));
$cart->add(new CartItem('Тетрадь', 10000, 2));
echo $cart->total(), ' коп.', PHP_EOL;
var_dump($cart->total() === 70000);
try {
$cart->add(new CartItem('Ошибка', 10000, 0));
} catch (InvalidArgumentException $error) {
echo $error->getMessage(), PHP_EOL;
}70000 коп.
bool(true)
Некорректная позицияПроверка показывает совпадение результата и отказ для некорректной позиции. Комментарий list<CartItem> помогает анализатору понимать тип элементов массива. Сам PHP проверяет параметр add(), но не тип элементов любого массива.
Для переноса этих классов в проект с Composer создайте отдельные файлы. Например, App\Shop\Cart поместите в src/Shop/Cart.php. В точке входа подключите автозагрузчик и импортируйте оба класса.
Не добавляйте репозитории, фабрики и интерфейсы ради количества конструкций. У этой корзины пока нет внешних зависимостей. Для нее достаточно двух классов с проверяемыми обязанностями.
Ошибки при переходе на ООП в PHP
Замена функций методами сама по себе не улучшает архитектуру. Проверяйте, кто владеет состоянием и какие правила защищает класс. Исправление обычно начинается с разделения обязанностей и явных зависимостей.
Божественный класс
Класс ShopManager, который считает корзину, строит HTML и отправляет письма, трудно менять. Разделите расчет и представление результата. Политика изменения цен тогда не затронет код вывода.
<?php
declare(strict_types=1);
final class TotalCalculator
{
public function calculate(array $prices): int
{
return array_sum($prices);
}
}
final class TotalPresenter
{
public function present(int $total): string
{
return $total . ' коп.';
}
}
$calculator = new TotalCalculator();
$presenter = new TotalPresenter();
echo $presenter->present($calculator->calculate([50000, 20000])), PHP_EOL;70000 коп.Публичные свойства для любого состояния
Публичный изменяемый остаток позволяет записать отрицательное количество товара. Закройте свойство и выразите изменение отдельным методом.
Публичные readonly-свойства объектов значений при этом вполне уместны.
<?php
declare(strict_types=1);
final class Inventory
{
private int $quantity = 0;
public function receive(int $quantity): void
{
if ($quantity < 1) {
throw new InvalidArgumentException('Количество должно быть положительным');
}
$this->quantity += $quantity;
}
public function quantity(): int
{
return $this->quantity;
}
}
$inventory = new Inventory();
$inventory->receive(3);
echo $inventory->quantity(), PHP_EOL;3Наследование вместо композиции
Заказ, который отправляет уведомления, не должен наследоваться от отправителя. Передайте отправителя в конструктор заказа. Интерфейс позволит заменить способ доставки уведомления без изменения заказа.
<?php
declare(strict_types=1);
interface Notifier
{
public function send(string $message): void;
}
final class ConsoleNotifier implements Notifier
{
public function send(string $message): void
{
echo $message, PHP_EOL;
}
}
final class Order
{
public function __construct(private Notifier $notifier) {}
public function confirm(): void
{
$this->notifier->send('Заказ подтвержден');
}
}
$order = new Order(new ConsoleNotifier());
$order->confirm();Заказ подтвержденСтатические методы как замена всем функциям
Статический сервис со скрытыми настройками затрудняет создание независимых сценариев. Передавайте настройки экземпляру через конструктор. Если операция не хранит состояние и не требует зависимостей, обычная функция тоже подходит.
<?php
declare(strict_types=1);
final class PriceFormatter
{
public function __construct(private string $currency) {}
public function format(int $amount): string
{
return $amount . ' ' . $this->currency;
}
}
$rubles = new PriceFormatter('RUB');
$dollars = new PriceFormatter('USD');
echo $rubles->format(500), PHP_EOL;
echo $dollars->format(10), PHP_EOL;500 RUB
10 USDВыбирайте класс для состояния с правилами изменения или явных зависимостей. Интерфейс пригодится, когда потребителю нужен общий контракт разных реализаций. Наследование используйте для совместимых разновидностей, композицию – для сотрудничества объектов.
Переносите процедурный код небольшими участками. Сначала сохраните проверку исходного результата, затем меняйте структуру. Такой порядок помогает отличить архитектурное изменение от случайной поломки расчета.
Популярное за неделю
- Как создать сайт самому в 2026: 4 способа + пошаговая инструкция 34 мин чтения
- Лучшие конструкторы для создания сайтов — плюсы, минусы и сравнения 22 мин чтения
- Как сделать переход на другую страницу в PHP 5 мин чтения
- Как создать календарь на AJAX и PHP 5 мин чтения
- Создание форм регистрации и авторизации на PHP 7 мин чтения
- База данных картинка: загрузка на сервер или в MySQL через PHP 12 мин чтения
Комментарии