🐘 PHP

OOP: Klassen und Objekte in PHP: Eine ausführliche Anleitung

Lektion 16 / 35 • Vollständige Lektüre-Theorie

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты — архитектор. Ты проектируешь дома. У тебя есть чертёж дома. На чертеже указано: сколько будет этажей, какого цвета стены, где находятся окна и двери. По этому одному чертежу можно построить много одинаковых домов. Все они будут похожи друг на друга, но стоять в разных местах, и в каждом будут жить разные люди.

В программировании Класс — это и есть такой чертёж. Он описывает, какие свойства (например, цвет, размер) и какие действия (например, открыть дверь, включить свет) будут у будущего объекта.

Объект — это конкретный дом, построенный по этому чертежу. У каждого объекта есть своя «память»: в одном доме живёт семья Петровых, в другом — Ивановых. Но оба дома умеют делать одно и то же: открывать двери и включать свет.

💡 Зачем это нужно? Без ООП (объектно-ориентированного программирования) ты бы писал одну и ту же логику для каждого дома отдельно. С классами ты пишешь код один раз, а потом создаёшь сколько угодно объектов. Это экономит время, уменьшает количество ошибок и делает программу понятной.

В реальной жизни классы используются везде: в играх (класс «Персонаж», объекты — «Марио», «Луиджи»), в интернет-магазинах (класс «Товар», объекты — «Кроссовки», «Футболка»), в социальных сетях (класс «Пользователь», объекты — «Анна», «Иван»).

Теория: как это работает изнутри

Давай заглянем «под капот» PHP и посмотрим, что происходит в памяти компьютера, когда ты работаешь с классами и объектами.

Что хранится в классе?

Класс — это просто набор инструкций. Он не занимает много памяти, пока ты не создашь объект. Внутри класса есть:

Свойства (поля) — переменные, которые описывают состояние объекта. Например, имя, возраст, цвет.
Методы — функции, которые описывают поведение объекта. Например, бежать, говорить, считать.

Как создаётся объект?

Когда ты пишешь new ИмяКласса(), PHP делает три вещи:

Выделяет память в оперативной памяти под новый объект.
Вызывает конструктор (специальный метод __construct()), который устанавливает начальные значения свойств.
Возвращает ссылку на этот объект. Ты сохраняешь эту ссылку в переменную, чтобы потом обращаться к объекту.

⚠️ Важно! Переменная хранит не сам объект, а ссылку на него. Если ты присвоишь один объект другой переменной, обе переменные будут указывать на один и тот же объект. Изменишь через одну — изменится и для другой.

Жизненный цикл объекта

Объект живёт до тех пор, пока на него есть хотя бы одна ссылка. Как только все переменные, указывающие на объект, удаляются или перезаписываются, PHP запускает сборщик мусора и уничтожает объект, освобождая память.

Статические методы и свойства

Иногда нужно, чтобы свойство или метод принадлежали не объекту, а самому классу. Например, счётчик созданных объектов. Для этого используется ключевое слово static. Такие методы и свойства вызываются через ::, а не через ->.

Синтаксис в PHP: все формы и варианты

Давай разберём полный синтаксис класса в PHP. Вот как выглядит «скелет» класса:

<?php
// Объявление класса
class ИмяКласса {
    // 1. Свойства (поля)
    // Модификаторы доступа: public, protected, private
    public $свойство1;           // Доступно отовсюду
    protected $свойство2;        // Доступно только внутри класса и в наследниках
    private $свойство3;          // Доступно только внутри этого класса
    
    // Типизированные свойства (с PHP 7.4+)
    public string $имя;
    public int $возраст;
    public ?string $отчество;    // Может быть null
    
    // Свойства со значением по умолчанию
    public $цвет = 'белый';
    
    // Константы класса
    const КОНСТАНТА = 'значение';
    
    // 2. Конструктор (вызывается при создании объекта)
    public function __construct($параметр1, $параметр2) {
        // $this - ссылка на текущий объект
        $this->свойство1 = $параметр1;
        $this->свойство2 = $параметр2;
    }
    
    // 3. Методы (функции класса)
    public function имяМетода() {
        // Логика метода
        return $this->свойство1;
    }
    
    // 4. Геттеры и сеттеры (для доступа к private свойствам)
    public function getСвойство3() {
        return $this->свойство3;
    }
    
    public function setСвойство3($значение) {
        $this->свойство3 = $значение;
    }
    
    // 5. Статические методы (принадлежат классу, а не объекту)
    public static function статическийМетод() {
        // Нельзя использовать $this
        return self::КОНСТАНТА;
    }
    
    // 6. Деструктор (вызывается при удалении объекта)
    public function __destruct() {
        echo "Объект уничтожен";
    }
}
?>

Модификаторы доступа: таблица

Модификатор	Где можно использовать	Пример
`public`	Везде: внутри класса, в наследниках, снаружи	`$obj->свойство`
`protected`	Только внутри класса и в классах-наследниках	`$this->свойство`
`private`	Только внутри этого класса	`$this->свойство`

Создание объекта

// Создание объекта
$объект = new ИмяКласса(аргументы);

// Обращение к свойствам и методам
$объект->свойство;          // Получить значение
$объект->свойство = 5;      // Установить значение
$объект->метод();           // Вызвать метод

// Статические вызовы
ИмяКласса::статическийМетод();
ИмяКласса::КОНСТАНТА;

Примеры кода — от простого к сложному

Пример 1: Простейший класс «Собака»

<?php
// Создаём класс Собака
class Dog {
    // Свойства: имя и возраст
    public $name;
    public $age;
    
    // Метод: подать голос
    public function bark() {
        // $this - ссылка на текущую собаку
        echo $this->name . " говорит: Гав-гав!";
    }
}

// Создаём объект (конкретную собаку)
$myDog = new Dog();
$myDog->name = "Бобик";    // Устанавливаем имя
$myDog->age = 3;           // Устанавливаем возраст

// Вызываем метод
$myDog->bark();            // Выведет: Бобик говорит: Гав-гав!
?>

Объяснение: Мы создали класс Dog с двумя свойствами и одним методом. Потом создали объект $myDog, заполнили его данные и вызвали метод. Обрати внимание: мы использовали $this внутри метода — это ссылка на тот объект, у которого вызван метод.

Пример 2: Конструктор и типизация

<?php
class Car {
    // Типизированные свойства
    public string $brand;
    public string $color;
    public int $year;
    
    // Конструктор с типизированными параметрами
    public function __construct(string $brand, string $color, int $year) {
        $this->brand = $brand;
        $this->color = $color;
        $this->year = $year;
    }
    
    // Метод для вывода информации
    public function getInfo(): string {
        return "{$this->brand} ({$this->year}), цвет: {$this->color}";
    }
}

// Создаём объект, передавая параметры в конструктор
$myCar = new Car("Toyota", "красный", 2020);
echo $myCar->getInfo();  // Toyota (2020), цвет: красный
?>

Объяснение: Конструктор __construct() автоматически вызывается при создании объекта. Мы сразу передаём все нужные данные. Типизация (string, int) помогает избежать ошибок — PHP проверит, что переданы данные правильного типа.

Пример 3: Инкапсуляция (private + геттеры/сеттеры)

<?php
class BankAccount {
    // Приватное свойство — никто не может изменить его напрямую
    private float $balance;
    
    public function __construct(float $initialBalance) {
        if ($initialBalance < 0) {
            throw new Exception("Баланс не может быть отрицательным");
        }
        $this->balance = $initialBalance;
    }
    
    // Геттер — только для чтения
    public function getBalance(): float {
        return $this->balance;
    }
    
    // Сеттер с проверкой
    public function deposit(float $amount): void {
        if ($amount <= 0) {
            throw new Exception("Сумма должна быть положительной");
        }
        $this->balance += $amount;
    }
    
    // Ещё один метод с проверкой
    public function withdraw(float $amount): void {
        if ($amount > $this->balance) {
            throw new Exception("Недостаточно средств");
        }
        $this->balance -= $amount;
    }
}

$account = new BankAccount(1000);
$account->deposit(500);
echo $account->getBalance();  // 1500
// $account->balance = 999999;  // Ошибка! Нельзя обратиться к private
?>

Объяснение: Свойство $balance — приватное. Доступ к нему возможен только через методы getBalance(), deposit() и withdraw(). Это называется инкапсуляция — мы скрываем внутреннее состояние объекта и контролируем, как к нему обращаются.

Пример 4: Статические свойства и методы

<?php
class User {
    // Статическое свойство — принадлежит классу, а не объекту
    private static int $userCount = 0;
    
    public string $name;
    
    public function __construct(string $name) {
        $this->name = $name;
        // Увеличиваем счётчик при создании каждого пользователя
        self::$userCount++;
    }
    
    // Статический метод — вызывается через User::getCount()
    public static function getCount(): int {
        return self::$userCount;
    }
    
    public function __destruct() {
        // Уменьшаем счётчик при удалении пользователя
        self::$userCount--;
    }
}

$user1 = new User("Анна");
$user2 = new User("Иван");
echo User::getCount();  // 2

unset($user1);          // Удаляем объект
echo User::getCount();  // 1
?>

Объяснение: Статические свойства и методы принадлежат классу, а не объекту. self:: используется для обращения к статическим членам внутри класса. Снаружи вызываем через User::getCount().

Пример 5: Наследование

<?php
// Базовый класс
class Animal {
    protected string $name;
    
    public function __construct(string $name) {
        $this->name = $name;
    }
    
    public function makeSound(): string {
        return "Какой-то звук";
    }
}

// Дочерний класс — наследует всё от Animal
class Cat extends Animal {
    // Переопределяем метод родителя
    public function makeSound(): string {
        return "{$this->name} говорит: Мяу!";
    }
    
    // Добавляем новый метод
    public function purr(): string {
        return "{$this->name} мурлычет...";
    }
}

class Dog2 extends Animal {
    public function makeSound(): string {
        return "{$this->name} говорит: Гав!";
    }
}

$cat = new Cat("Мурка");
$dog = new Dog2("Шарик");

echo $cat->makeSound();  // Мурка говорит: Мяу!
echo $dog->makeSound();  // Шарик говорит: Гав!
echo $cat->purr();       // Мурка мурлычет...
?>

Объяснение: Классы Cat и Dog2 наследуют от Animal свойство $name и метод makeSound(), но переопределяют его. Это полиморфизм — один и тот же метод ведёт себя по-разному в разных классах.

Пример 6: Интерфейсы

<?php
// Интерфейс — контракт, который должен выполнить класс
interface PaymentMethod {
    public function pay(float $amount): bool;
    public function getType(): string;
}

// Класс, реализующий интерфейс
class CreditCard implements PaymentMethod {
    public function pay(float $amount): bool {
        echo "Оплачено {$amount} руб. картой";
        return true;
    }
    
    public function getType(): string {
        return "Кредитная карта";
    }
}

class PayPal implements PaymentMethod {
    public function pay(float $amount): bool {
        echo "Оплачено {$amount} руб. через PayPal";
        return true;
    }
    
    public function getType(): string {
        return "PayPal";
    }
}

// Функция, которая принимает любой объект, реализующий интерфейс
function processPayment(PaymentMethod $method, float $amount) {
    echo "Способ оплаты: " . $method->getType() . "
";
    $method->pay($amount);
}

$card = new CreditCard();
$paypal = new PayPal();

processPayment($card, 1500);    // Способ оплаты: Кредитная карта
processPayment($paypal, 2000);  // Способ оплаты: PayPal
?>

Объяснение: Интерфейс PaymentMethod определяет, какие методы должны быть у класса. Любой класс, который implements этот интерфейс, обязан реализовать все его методы. Это позволяет писать гибкий код — функция processPayment() работает с любым платёжным методом.

Пример 7: Трейты (примеси)

<?php
// Трейт — набор методов, которые можно "примешивать" к классам
trait Logger {
    public function log(string $message): void {
        echo "[LOG] " . date('Y-m-d H:i:s') . " - " . $message . "
";
    }
}

trait Timestamp {
    public function getTimestamp(): string {
        return date('Y-m-d H:i:s');
    }
}

class Order {
    // Используем трейты
    use Logger, Timestamp;
    
    private array $items = [];
    
    public function addItem(string $item): void {
        $this->items[] = $item;
        $this->log("Добавлен товар: " . $item);
    }
    
    public function getInfo(): string {
        return "Заказ создан: " . $this->getTimestamp();
    }
}

$order = new Order();
$order->addItem("Ноутбук");
$order->addItem("Мышь");
echo $order->getInfo();
?>

Объяснение: Трейты позволяют переиспользовать методы в разных классах без наследования. Класс Order использует два трейта и получает их методы. Это удобно, когда нужно добавить одинаковую функциональность в разные, не связанные иерархией классы.

Сравнение с Python: чем похоже и чем отличается

Аспект	PHP	Python
Объявление класса	`class MyClass { }`	`class MyClass:`
Конструктор	`function __construct()`	`def __init__(self)`
Ссылка на текущий объект	`$this`	`self`
Модификаторы доступа	`public`, `protected`, `private`	Нет ключевых слов. `_` — защищённый, `__` — приватный (соглашение)
Типизация свойств	Поддерживается с PHP 7.4 (`public string $name`)	Поддерживается с Python 3.6+ (`name: str`)
Статические методы	`public static function method()`	`@staticmethod` или `@classmethod`
Интерфейсы	`interface` + `implements`	`ABC` (Abstract Base Classes) + наследование
Трейты	`trait` + `use`	Нет трейтов, но есть множественное наследование
Создание объекта	`$obj = new Class()`	`obj = Class()`
Обращение к свойствам	`$obj->property`	`obj.property`
Магические методы	`__get()`, `__set()`, `__call()`	`__getattr__()`, `__setattr__()`, `__call__()`

💡 Главное отличие: PHP более строгий в синтаксисе (нужны $ перед переменными, -> для обращения, точки с запятой). Python более лаконичный. Но концептуально ООП в обоих языках очень похоже.

Типичные ошибки и подводные камни

1. Забыл `$this`

class User {
    public $name;
    
    public function setName($name) {
        $name = $name;  // Ошибка! Присваивается параметру, а не свойству
        // Правильно: $this->name = $name;
    }
}

2. Путаница между `=` и `==` при сравнении объектов

$a = new User("Анна");
$b = new User("Анна");
$c = $a;

var_dump($a == $b);   // true — сравниваются свойства
var_dump($a === $b);  // false — разные объекты
var_dump($a === $c);  // true — одна и та же ссылка

3. Изменение объекта через копию

$original = new User("Анна");
$copy = $original;        // Не копия, а та же ссылка!
$copy->name = "Иван";
echo $original->name;     // Выведет "Иван" — изменился оригинал!

// Для копирования используй clone:
$realCopy = clone $original;

4. Статические методы и `$this`

class Test {
    public static function method() {
        return $this->property;  // Ошибка! $this недоступен в статическом методе
    }
}

5. Неправильное использование `self` и `static`

class ParentClass {
    public static function who() {
        echo __CLASS__;
    }
    
    public static function test() {
        self::who();    // Всегда вызовет ParentClass::who()
        static::who();  // Вызовет метод того класса, который вызвал (позднее статическое связывание)
    }
}

class ChildClass extends ParentClass {
    public static function who() {
        echo __CLASS__;
    }
}

ChildClass::test();  // Выведет: ParentClassChildClass

6. Забыл вызвать родительский конструктор

class ParentClass {
    public function __construct() {
        echo "Родительский конструктор";
    }
}

class ChildClass extends ParentClass {
    public function __construct() {
        // parent::__construct();  // Забыли вызвать!
        echo "Дочерний конструктор";
    }
}

$obj = new ChildClass();  // Выведет только "Дочерний конструктор"

Лучшие практики и советы профессионалов

Принцип единственной ответственности — один класс должен отвечать только за одну вещь. Не делай класс «User», который и данные хранит, и в базу пишет, и письма отправляет.
Используй типизацию — указывай типы свойств и возвращаемые типы методов. Это делает код самодокументируемым и предотвращает ошибки.
Делай свойства приватными — всегда начинай с private. Открывай доступ только если это действительно нужно. Это защищает данные от случайного изменения.
Именуй классы существительными — User, Order, PaymentProcessor. Методы называй глаголами — getUser(), processPayment().
Избегай «божественных объектов» — не создавай классы, которые делают всё. Разбивай на маленькие, специализированные классы.
Используй Dependency Injection — передавай зависимости через конструктор, а не создавай их внутри класса.
Не бойся интерфейсов — они делают код гибким. Ты можешь заменить одну реализацию на другую, не меняя код, который их использует.
Пиши тесты — ООП код легко тестировать. Для каждого класса пиши unit-тесты.
Используй PSR-4 для автозагрузки — один файл = один класс. Называй файл так же, как класс.
Документируй код — пиши PHPDoc комментарии для классов, методов и свойств.

🔥 Золотое правило: Если тебе кажется, что класс делает слишком много — разбей его на два. Если сомневаешься, какой модификатор доступа выбрать — выбирай самый строгий (private).

Вопросы для самопроверки

Вопрос: В чём разница между классом и объектом?

Ответ: Класс — это чертёж (шаблон), а объект — конкретный экземпляр, созданный по этому чертежу. Класс один, объектов может быть много.
Вопрос: Что такое $this и для чего он нужен?

Ответ: $this — это ссылка на текущий объект внутри его методов. Он нужен, чтобы обращаться к свойствам и методам этого же объекта.
Вопрос: Какие модификаторы доступа есть в PHP и чем они отличаются?

Ответ: public — доступен везде, protected — внутри класса и в наследниках, private — только внутри класса.
Вопрос: Что такое конструктор и зачем он нужен?

Ответ: Конструктор (__construct()) — это метод, который автоматически вызывается при создании объекта. Он нужен для инициализации свойств начальными значениями.
Вопрос: Чем отличается статический метод от обычного?

Ответ: Статический метод принадлежит классу, а не объекту. Его можно вызвать без создания объекта (ClassName::method()). Внутри статического метода нельзя использовать $this.
Вопрос: Что такое наследование и как его реализовать в PHP?

Ответ: Наследование — это механизм, при котором класс-потомок получает все свойства и методы родительского класса. Реализуется через ключевое слово extends.
Вопрос: Что такое интерфейс и чем он отличается от класса?

Ответ: Интерфейс определяет только сигнатуры методов (без реализации). Класс, реализующий интерфейс, обязан предоставить реализацию всех его методов. В отличие от класса, интерфейс не может содержать свойства с реализацией.
Вопрос: Что произойдёт, если присвоить один объект другой переменной?

Ответ: Обе переменные будут ссылаться на один и тот же объект. Изменения через одну переменную отразятся на другой. Для создания копии нужно использовать clone.
Вопрос: Для чего нужны трейты в PHP?

Ответ: Трейты позволяют переиспользовать наборы методов в разных классах, не связанных иерархией наследования. Это механизм «примешивания» функциональности.
Вопрос: Что такое инкапсуляция и зачем она нужна?

Ответ: Инкапсуляция — это сокрытие внутреннего состояния объекта и предоставление контролируемого доступа через методы. Она защищает данные от некорректного использования и упрощает поддержку кода.

Итог и что изучить дальше

Мы прошли большой путь. Ты узнал:

Что классы — это чертежи, а объекты — конкретные экземпляры.
Как объявлять классы, свойства и методы в PHP.
Как работают конструкторы, деструкторы и статические члены.
Что такое инкапсуляция, наследование и полиморфизм.
Как использовать интерфейсы и трейты.
Какие ошибки чаще всего допускают новички.
Лучшие практики написания ООП-кода.

Теперь ты готов двигаться дальше. Вот что стоит изучить следующим шагом:

Паттерны проектирования — готовые решения типовых задач. Начни с Singleton, Factory, Observer.
SOLID — пять принципов ООП, которые делают код гибким и поддерживаемым.
Composer и автозагрузка — как организовать классы в проекте и подключать их автоматически.
Исключения — как правильно обрабатывать ошибки в ООП-стиле.
PHP-фреймворки — Laravel, Symfony. Они используют ООП на полную мощность.
Тестирование — PHPUnit для написания тестов к классам.

🎯 Помни: ООП — это не про синтаксис. Это про мышление. Ты учишься думать объектами, видеть в реальном мире сущности и их взаимодействие. Это навык, который приходит с практикой. Пиши код каждый день, и скоро ты будешь проектировать

← Vorherige Funktionen und Rekursion in PHP 8.2: Ausführlicher Weiter → OOP: Vererbung in PHP: Eine ausführliche Anleitung