ООП в PHP: мощные возможности классов и объектов для разработки

// Определение класса
class User {
// Тело класса
}

// Создание объекта
$john = new User();

class User {
// Свойства (атрибуты) класса
public $username;
public $email;

// Конструктор – специальный метод, вызываемый при создании объекта
public function __construct($username, $email) {
$this->username = $username;
$this->email = $email;
}

// Метод класса
public function getEmailDomain() {
$parts = explode('@', $this->email);
return end($parts);
}
}

// Создание объекта с параметрами
$user = new User('john_doe', 'john@example.com');

// Обращение к свойству
echo $user->username; // Выведет: john_doe

// Вызов метода
echo $user->getEmailDomain(); // Выведет: example.com

class DatabaseConnection {
private $connection;

public function __construct($server, $username, $password) {
// Открываем соединение при создании объекта
$this->connection = new mysqli($server, $username, $password);
}

public function __destruct() {
// Закрываем соединение при уничтожении объекта
$this->connection->close();
}
}

class BankAccount {
// Приватное свойство – доступно только внутри класса
private $balance = 0;

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

// Публичное свойство – доступно отовсюду
public $ownerName;

public function __construct($ownerName, $accountNumber) {
$this->ownerName = $ownerName;
$this->accountNumber = $accountNumber;
}

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

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

// Приватный метод – вспомогательная функция
private function validateTransaction($amount) {
return $amount <= $this->balance;
}
}

class Product {
public string $name;
public float $price;
private int $stockQuantity;

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

// Метод с типизированным возвращаемым значением
public function isInStock(): bool {
return $this->stockQuantity > 0;
}

// Метод с типизированными параметрами
public function reduceStock(int $quantity): void {
if ($quantity <= $this->stockQuantity) {
$this->stockQuantity -= $quantity;
}
}
}

class Counter {
// Статическое свойство – общее для всех экземпляров
private static int $count = 0;

public function __construct() {
// Увеличиваем счётчик при создании объекта
self::$count++;
}

// Статический метод – можно вызвать без создания объекта
public static function getCount(): int {
return self::$count;
}
}

// Использование:
$obj1 = new Counter();
$obj2 = new Counter();
echo Counter::getCount(); // Выведет: 2

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

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

public function getInfo() {
return "$this->year $this->brand $this->model";
}

public function startEngine() {
return "Engine started!";
}
}

// Дочерний класс
class Car extends Vehicle {
private $numDoors;

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

// Переопределение метода родительского класса
public function getInfo() {
// Используем родительский метод и дополняем его
return parent::getInfo() . ", $this->numDoors doors";
}

// Новый метод, специфичный для Car
public function honk() {
return "Beep beep!";
}
}

// Ещё один дочерний класс
class Motorcycle extends Vehicle {
private $hasSidecar;

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

// Переопределение метода с полностью новой логикой
public function startEngine() {
return "Kickstart engaged!";
}
}

// Использование классов
$car = new Car("Toyota", "Corolla", 2020, 4);
echo $car->getInfo(); // 2020 Toyota Corolla, 4 doors
echo $car->startEngine(); // Engine started!
echo $car->honk(); // Beep beep!

$motorcycle = new Motorcycle("Harley-Davidson", "Street 750", 2019, false);
echo $motorcycle->getInfo(); // 2019 Harley-Davidson Street 750
echo $motorcycle->startEngine(); // Kickstart engaged!

abstract class PaymentGateway {
protected $amount;

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

// Общий метод для всех платёжных шлюзов
public function getAmount() {
return $this->amount;
}

// Абстрактный метод – должен быть реализован в дочерних классах
abstract public function processPayment(): bool;
}

class PayPalGateway extends PaymentGateway {
private $email;

public function __construct($amount, $email) {
parent::__construct($amount);
$this->email = $email;
}

// Реализация абстрактного метода
public function processPayment(): bool {
// Логика обработки платежа через PayPal
return true; // Успешный платёж
}
}

class StripeGateway extends PaymentGateway {
private $cardNumber;

public function __construct($amount, $cardNumber) {
parent::__construct($amount);
$this->cardNumber = $cardNumber;
}

// Реализация абстрактного метода
public function processPayment(): bool {
// Логика обработки платежа через Stripe
return true; // Успешный платёж
}
}

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

interface Serializable {
public function serialize(): string;
public function unserialize(string $data);
}

// Класс может реализовывать несколько интерфейсов
class User implements Loggable, Serializable {
private $username;
private $logHistory = [];

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

// Реализация методов интерфейса Loggable
public function log($message) {
$this->logHistory[] = date('Y-m-d H:i:s') . ": $message";
}

public function getLogHistory(): array {
return $this->logHistory;
}

// Реализация методов интерфейса Serializable
public function serialize(): string {
return serialize([
'username' => $this->username,
'logs' => $this->logHistory
]);
}

public function unserialize(string $data) {
$data = unserialize($data);
$this->username = $data['username'];
$this->logHistory = $data['logs'];
}
}

class Database {
// Статическое свойство для хранения единственного экземпляра
private static $instance = null;

private $connection;

// Закрытый конструктор, чтобы предотвратить прямое создание
private function __construct() {
$this->connection = new mysqli('localhost', 'username', 'password', 'database');
}

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

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

// Запрещаем десериализацию
public function __wakeup() {
throw new Exception("Cannot unserialize singleton");
}

// Метод для выполнения запросов
public function query($sql) {
return $this->connection->query($sql);
}
}

// Использование:
$db = Database::getInstance();
$result = $db->query("SELECT * FROM users");

// Интерфейс для оповещений
interface NotificationService {
public function send($message, $recipient);
}

// Реализация email-уведомлений
class EmailNotification implements NotificationService {
public function send($message, $recipient) {
// Логика отправки email
return "Email sent to $recipient: $message";
}
}

// Реализация SMS-уведомлений
class SmsNotification implements NotificationService {
public function send($message, $recipient) {
// Логика отправки SMS
return "SMS sent to $recipient: $message";
}
}

// Абстрактный класс для товаров
abstract class Product {
protected $id;
protected $name;
protected $price;

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

public function getId() {
return $this->id;
}

public function getName() {
return $this->name;
}

public function getPrice() {
return $this->price;
}

// Абстрактный метод для расчёта стоимости доставки
abstract public function calculateShippingCost(): float;
}

// Физический товар
class PhysicalProduct extends Product {
private $weight;

public function __construct($id, $name, $price, $weight) {
parent::__construct($id, $name, $price);
$this->weight = $weight;
}

public function calculateShippingCost(): float {
// Расчёт стоимости доставки на основе веса
return $this->weight * 5.0;
}
}

// Цифровой товар
class DigitalProduct extends Product {
public function calculateShippingCost(): float {
// Цифровые товары не требуют доставки
return 0.0;
}
}

// Класс корзины
class Cart {
private $items = [];

public function addItem(Product $product, $quantity) {
$this->items[] = [
'product' => $product,
'quantity' => $quantity
];
}

public function removeItem($productId) {
foreach ($this->items as $key => $item) {
if ($item['product']->getId() === $productId) {
unset($this->items[$key]);
break;
}
}
}

public function getTotalPrice() {
$total = 0;
foreach ($this->items as $item) {
$total += $item['product']->getPrice() * $item['quantity'];
}
return $total;
}

public function getItems() {
return $this->items;
}
}

// Класс заказа
class Order {
private $orderId;
private $customer;
private $items;
private $totalPrice;
private $notificationService;

public function __construct($orderId, $customer, Cart $cart, NotificationService $notificationService) {
$this->orderId = $orderId;
$this->customer = $customer;
$this->items = $cart->getItems();
$this->totalPrice = $cart->getTotalPrice();
$this->notificationService = $notificationService;
}

public function process() {
// Логика обработки заказа

// Отправка уведомления
$message = "Your order #$this->orderId for $$this->totalPrice has been processed.";
return $this->notificationService->send($message, $this->customer);
}
}

// Использование:
// Создание товаров
$phone = new PhysicalProduct(1, "Smartphone", 499.99, 0.3);
$ebook = new DigitalProduct(2, "Programming PHP", 29.99);

// Создание корзины
$cart = new Cart();
$cart->addItem($phone, 1);
$cart->addItem($ebook, 1);

// Выбор способа уведомления
$notificationService = new EmailNotification();

// Создание и обработка заказа
$order = new Order(12345, "john.doe@example.com", $cart, $notificationService);
echo $order->process();