Используешь ли ООП при написании кода

Использование ООП при написании кода

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

Принципы SOLID

При работе с ООП я придерживаюсь принципов SOLID, которые обеспечивают качество и maintainability кода:

# S — Single Responsibility: класс отвечает за одно
class UserRepository:
    def get_by_id(self, user_id: int) -> User:
        pass

class UserService:
    def __init__(self, repo: UserRepository):
        self.repo = repo
    
    def authenticate(self, email: str, password: str) -> User:
        pass

# O — Open/Closed: открыт для расширения, закрыт для модификации
from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool:
        pass

class StripeProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool:
        # Stripe API
        pass

class PayPalProcessor(PaymentProcessor):
    def process(self, amount: float) -> bool:
        # PayPal API
        pass

Когда ООП имеет смысл

1. Моделирование сущностей — когда есть логичное отображение реальных объектов:

class User:
    def __init__(self, id: int, email: str, name: str):
        self.id = id
        self.email = email
        self.name = name
    
    def is_active(self) -> bool:
        return self.email_verified and self.subscription_active
    
    def send_email(self, subject: str, body: str) -> None:
        # Отправка email
        pass

2. Полиморфизм — когда нужно работать с разными типами объектов одинаково:

from typing import List

class Storage(ABC):
    @abstractmethod
    def save(self, data: dict) -> None:
        pass

class DatabaseStorage(Storage):
    def save(self, data: dict) -> None:
        # Сохранение в БД
        pass

class FileStorage(Storage):
    def save(self, data: dict) -> None:
        # Сохранение в файл
        pass

def export_user_data(user: User, storage: Storage):
    storage.save(user.__dict__)

# Работает с любым типом хранилища
export_user_data(user, DatabaseStorage())
export_user_data(user, FileStorage())

Когда я избегаю избыточного ООП

Функциональный подход лучше для простых операций:

# Плохо — избыточное ООП
class Calculator:
    def add(self, a: float, b: float) -> float:
        return a + b

calc = Calculator()
result = calc.add(5, 3)

# Хорошо — просто функция
def add(a: float, b: float) -> float:
    return a + b

result = add(5, 3)

Инкапсуляция

Я использую приватные и защищённые члены для сокрытия реализации:

class BankAccount:
    def __init__(self, balance: float):
        self._balance = balance  # Защищённый
        self.__pin = "****"      # Приватный
    
    def withdraw(self, amount: float) -> bool:
        if amount > self._balance:
            return False
        self._balance -= amount
        return True
    
    @property
    def balance(self) -> float:
        return self._balance

Наследование (осторожно)

Использую наследование для переиспользования кода и определения контрактов, но предпочитаю композицию:

# Наследование — для интерфейсов
class Animal(ABC):
    @abstractmethod
    def make_sound(self) -> str:
        pass

class Dog(Animal):
    def make_sound(self) -> str:
        return "Woof"

# Композиция — для переиспользования функционала
class Robot:
    def __init__(self, speaker: Speaker):
        self.speaker = speaker  # Агрегация, не наследование
    
    def greet(self):
        self.speaker.speak("Hello")

Практический пример: DDD (Domain-Driven Design)

В больших проектах я использую ООП в контексте DDD:

from dataclasses import dataclass
from datetime import datetime

@dataclass
class Order:
    """Сущность заказа"""
    id: str
    user_id: str
    total_price: float
    created_at: datetime
    
    def apply_discount(self, percentage: float) -> None:
        self.total_price *= (1 - percentage / 100)
    
    def is_recent(self) -> bool:
        return (datetime.now() - self.created_at).days < 30

class OrderRepository:
    """Репозиторий для работы с заказами"""
    def get_by_id(self, order_id: str) -> Order:
        pass
    
    def save(self, order: Order) -> None:
        pass

Заключение

Я использую ООП как инструмент, а не как догму. Выбираю его когда он:

• Делает код более понятным и структурированным
• Помогает переиспользовать код
• Определяет чёткие контракты между компонентами
• Упрощает тестирование через dependency injection

Для простых скриптов или функциональных задач я выбираю функциональный подход. Баланс между ООП и функциональным стилем — вот что делает код качественным.