ООП в PHP: от процедурного кода к архитектурным решениям

class User {
// Свойства класса
public $username;
public $email;

// Метод класса
public function register() {
echo "Пользователь {$this->username} зарегистрирован";
}
}

// Создание объекта
$user = new User();
$user->username = "john_doe";
$user->email = "john@example.com";
$user->register(); // Вывод: Пользователь john_doe зарегистрирован

class User {
public $username;
public $email;

// Конструктор
public function __construct($username, $email) {
$this->username = $username;
$this->email = $email;
echo "Объект пользователя создан";
}

// Деструктор
public function __destruct() {
echo "Объект пользователя {$this->username} уничтожен";
}
}

// Создание объекта с передачей параметров в конструктор
$user = new User("jane_smith", "jane@example.com");

class Database {
// Статическое свойство
private static $connection = null;

// Статический метод
public static function connect() {
if (self::$connection === null) {
self::$connection = new PDO('mysql:host=localhost;dbname=myapp', 'root', 'password');
}
return self::$connection;
}
}

// Вызов статического метода без создания объекта
$db = Database::connect();

class BankAccount {
// Приватное свойство — прямой доступ запрещён
private $balance = 0;

// Защищённое свойство — доступно в дочерних классах
protected $accountNumber;

// Публичный метод — интерфейс для работы с балансом
public function deposit($amount) {
if ($amount > 0) {
$this->balance += $amount;
return true;
}
return false;
}

// Публичный метод для снятия средств
public function withdraw($amount) {
if ($amount > 0 && $this->balance >= $amount) {
$this->balance -= $amount;
return true;
}
return false;
}

// Публичный метод для получения баланса
public function getBalance() {
return $this->balance;
}

// Защищённый метод — может использоваться в дочерних классах
protected function generateStatement() {
return "Баланс счета {$this->accountNumber}: {$this->balance}";
}
}

$account = new BankAccount();
$account->deposit(1000);
echo $account->getBalance(); // 1000

// Это вызовет ошибку, так как свойство приватное
// echo $account->balance;

// Это также вызовет ошибку, так как метод защищённый
// $account->generateStatement();

class User {
private $email;
private $age;

public function setEmail($email) {
// Валидация email перед установкой
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
$this->email = $email;
return true;
}
return false;
}

public function getEmail() {
return $this->email;
}

public function setAge($age) {
// Проверка на корректность возраста
$age = (int)$age;
if ($age >= 0 && $age <= 120) {
$this->age = $age;
return true;
}
return false;
}

public function getAge() {
return $this->age;
}
}

$user = new User();
if (!$user->setEmail('invalid')) {
echo "Некорректный email!";
}

class Product {
private string $name;
private float $price;
private int $stock = 0;

public function __construct(string $name, float $price) {
$this->name = $name;
$this->price = $price;
}

// Методы класса...
}

// Это вызовет TypeError, так как тип не соответствует
// $product = new Product(123, 'not a float');

// Базовый класс
class Vehicle {
protected $brand;
protected $year;

public function __construct($brand, $year) {
$this->brand = $brand;
$this->year = $year;
}

public function start() {
return "Транспортное средство {$this->brand} запущено";
}

public function getBrand() {
return $this->brand;
}
}

// Дочерний класс, наследующий Vehicle
class Car extends Vehicle {
private $doors;

public function __construct($brand, $year, $doors) {
// Вызов конструктора родителя
parent::__construct($brand, $year);
$this->doors = $doors;
}

// Переопределение метода родителя
public function start() {
return "Автомобиль {$this->brand} запущен с помощью ключа";
}

// Новый метод, доступный только в Car
public function honk() {
return "Бип-бип!";
}
}

// Ещё один дочерний класс
class ElectricCar extends Car {
private $batteryCapacity;

public function __construct($brand, $year, $doors, $batteryCapacity) {
parent::__construct($brand, $year, $doors);
$this->batteryCapacity = $batteryCapacity;
}

// Переопределение метода
public function start() {
return "Электромобиль {$this->brand} запущен бесшумно";
}

// Метод, специфичный для электромобиля
public function charge() {
return "Зарядка...";
}
}

$vehicle = new Vehicle("Generic", 2020);
$car = new Car("Toyota", 2021, 4);
$electricCar = new ElectricCar("Tesla", 2022, 4, "100kWh");

echo $vehicle->start(); // Транспортное средство Generic запущено
echo $car->start(); // Автомобиль Toyota запущен с помощью ключа
echo $electricCar->start(); // Электромобиль Tesla запущен бесшумно

// Абстрактный класс
abstract class Shape {
// Абстрактный метод без реализации
abstract public function calculateArea();

// Обычный метод с реализацией
public function getDescription() {
return "Это геометрическая фигура";
}
}

// Конкретная реализация абстрактного класса
class Circle extends Shape {
private $radius;

public function __construct($radius) {
$this->radius = $radius;
}

// Реализация абстрактного метода
public function calculateArea() {
return pi() * $this->radius * $this->radius;
}
}

// Другая реализация
class Rectangle extends Shape {
private $width;
private $height;

public function __construct($width, $height) {
$this->width = $width;
$this->height = $height;
}

public function calculateArea() {
return $this->width * $this->height;
}
}

// Функция, демонстрирующая полиморфизм
function printArea(Shape $shape) {
echo "Площадь фигуры: " . $shape->calculateArea();
}

$circle = new Circle(5);
$rectangle = new Rectangle(4, 6);

printArea($circle); // Площадь фигуры: 78.54
printArea($rectangle); // Площадь фигуры: 24

// Определение интерфейса
interface Serializable {
public function serialize();
public function unserialize($data);
}

interface Loggable {
public function log($message);
}

// Класс, реализующий интерфейсы
class User implements Serializable, Loggable {
private $name;
private $email;

public function __construct($name, $email) {
$this->name = $name;
$this->email = $email;
}

public function serialize() {
return json_encode([
'name' => $this->name,
'email' => $this->email
]);
}

public function unserialize($data) {
$obj = json_decode($data, true);
$this->name = $obj['name'];
$this->email = $obj['email'];
}

public function log($message) {
echo "[USER LOG] [{$this->name}]: {$message}";
}
}

$user = new User("John", "john@example.com");
$serialized = $user->serialize();
echo $serialized; // {"name":"John","email":"john@example.com"}

// Можно использовать type hinting для интерфейсов
function processSerializable(Serializable $obj) {
// Работаем с объектом, реализующим Serializable
}

processSerializable($user); // Работает, так как User реализует Serializable

class Database {
private static $instance = null;
private $connection;

// Закрытый конструктор, чтобы предотвратить создание через new
private function __construct() {
$this->connection = new PDO(
'mysql:host=localhost;dbname=myapp;charset=utf8',
'username',
'password',
[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]
);
}

// Запрещаем клонирование
private function __clone() {}

// Метод для получения единственного экземпляра
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}

public function getConnection() {
return $this->connection;
}

public function query($sql, $params = []) {
$stmt = $this->connection->prepare($sql);
$stmt->execute($params);
return $stmt;
}
}

// Использование
$db = Database::getInstance();
$users = $db->query("SELECT * FROM users WHERE status = ?", ['active'])->fetchAll();

// Интерфейс для всех платёжных систем
interface PaymentGateway {
public function processPayment($amount);
public function refund($transactionId);
}

// Реализация для PayPal
class PayPalGateway implements PaymentGateway {
private $apiKey;

public function __construct($apiKey) {
$this->apiKey = $apiKey;
}

public function processPayment($amount) {
// Логика интеграции с PayPal API
return "PayPal payment: $" . $amount . " processed";
}

public function refund($transactionId) {
return "PayPal refund for transaction {$transactionId} processed";
}
}

// Реализация для Stripe
class StripeGateway implements PaymentGateway {
private $secretKey;

public function __construct($secretKey) {
$this->secretKey = $secretKey;
}

public function processPayment($amount) {
// Логика интеграции с Stripe API
return "Stripe payment: $" . $amount . " processed";
}

public function refund($transactionId) {
return "Stripe refund for transaction {$transactionId} processed";
}
}

// Фабрика для создания платёжных шлюзов
class PaymentGatewayFactory {
public static function create($type, $credentials) {
switch ($type) {
case 'paypal':
return new PayPalGateway($credentials['apiKey']);
case 'stripe':
return new StripeGateway($credentials['secretKey']);
default:
throw new Exception("Unknown payment gateway type: {$type}");
}
}
}

// Класс для обработки платежей
class PaymentProcessor {
private $gateway;

public function __construct(PaymentGateway $gateway) {
$this->gateway = $gateway;
}

public function makePayment($amount) {
return $this->gateway->processPayment($amount);
}

public function issueRefund($transactionId) {
return $this->gateway->refund($transactionId);
}
}

// Использование
$credentials = ['secretKey' => 'sk_test_123456'];
$stripeGateway = PaymentGatewayFactory::create('stripe', $credentials);
$processor = new PaymentProcessor($stripeGateway);
echo $processor->makePayment(99.99);

// Интерфейс для всех логгеров
interface Logger {
public function log($message, $level);
}

// Абстрактный класс для базовой функциональности логирования
abstract class AbstractLogger implements Logger {
protected $levels = ['info', 'warning', 'error', 'critical'];

public function log($message, $level) {
if (!in_array($level, $this->levels)) {
throw new InvalidArgumentException("Invalid log level: {$level}");
}

return $this->write($message, $level);
}

// Абстрактный метод для конкретной реализации записи лога
abstract protected function write($message, $level);
}

// Логгер, записывающий в файл
class FileLogger extends AbstractLogger {
private $filePath;

public function __construct($filePath) {
$this->filePath = $filePath;
}

protected function write($message, $level) {
$date = date('Y-m-d H:i:s');
$logMessage = "[{$date}] [{$level}] {$message}" . PHP_EOL;
return file_put_contents($this->filePath, $logMessage, FILE_APPEND);
}
}

// Логгер, отправляющий в Syslog
class SyslogLogger extends AbstractLogger {
protected function write($message, $level) {
$priority = $this->mapLevelToPriority($level);
return syslog($priority, $message);
}

private function mapLevelToPriority($level) {
$map = [
'info' => LOG_INFO,
'warning' => LOG_WARNING,
'error' => LOG_ERR,
'critical' => LOG_CRIT
];
return $map[$level] ?? LOG_INFO;
}
}

// Логгер, объединяющий несколько логгеров
class CompositeLogger implements Logger {
private $loggers = [];

public function addLogger(Logger $logger) {
$this->loggers[] = $logger;
return $this;
}

public function log($message, $level) {
foreach ($this->loggers as $logger) {
$logger->log($message, $level);
}
}
}

// Использование
$fileLogger = new FileLogger('/var/log/myapp.log');
$syslogLogger = new SyslogLogger();

$logger = new CompositeLogger();
$logger->addLogger($fileLogger)
->addLogger($syslogLogger);

$logger->log("User authentication failed", "error");