Что такое объектно-ориентированное программирование (ООП)?

# Объектно-ориентированное программирование (ООП)

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

Основная идея

Вместо того чтобы писать:

# Процедурный подход - нарезать данные и функции отдельно
user_names = ['Alice', 'Bob']
user_ages = [30, 25]
user_emails = ['alice@example.com', 'bob@example.com']

def send_email(email, message):
    print(f'Отправляем {email}: {message}')

send_email(user_emails[0], 'Hello Alice')

Мы пишем:

# ООП подход - данные и методы вместе
class User:
    def __init__(self, name, age, email):
        self.name = name
        self.age = age
        self.email = email
    
    def send_email(self, message):
        print(f'Отправляем {self.email}: {message}')

alice = User('Alice', 30, 'alice@example.com')
alice.send_email('Hello Alice')

Четыре столпа ООП

1. Инкапсуляция (Encapsulation)

Инкапсуляция — это "упаковка" данных и методов вместе в объект, с контролем доступа к ним.

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Protected (обычно не трогаем)
        self.__pin = '1234'      # Private (совсем не трогаем)
    
    def deposit(self, amount):
        """Публичный метод для пополнения"""
        if amount > 0:
            self._balance += amount
        return self._balance
    
    def get_balance(self):
        """Публичный метод для получения баланса"""
        return self._balance
    
    def _calculate_interest(self):
        """Защищённый метод - вспомогательный"""
        return self._balance * 0.02

# Использование
account = BankAccount(1000)
print(account.get_balance())  # 1000
account.deposit(500)          # 1500
# account._BankAccount__pin    # Можно, но не нужно!

Преимущества:

• Контролируем доступ к данным
• Скрываем внутреннюю реализацию
• Снижаем связанность кода

2. Наследование (Inheritance)

Наследование позволяет создавать новые классы на основе существующих, переиспользуя и расширяя их функциональность.

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        return "Some sound"
    
    def sleep(self):
        return f"{self.name} спит"

class Dog(Animal):  # Dog наследует от Animal
    def make_sound(self):
        return f"{self.name} лает: Гав!"
    
    def fetch(self, item):
        return f"{self.name} принёс {item}"

class Cat(Animal):
    def make_sound(self):
        return f"{self.name} мяучит: Мяу!"
    
    def scratch(self):
        return f"{self.name} царапает"

# Использование
dog = Dog('Rex')
cat = Cat('Whiskers')

print(dog.make_sound())   # Rex лает: Гав!
print(cat.make_sound())   # Whiskers мяучит: Мяу!
print(dog.sleep())        # Rex спит (унаследовано)
print(dog.fetch('мяч'))   # Rex принёс мяч

3. Полиморфизм (Polymorphism)

Полиморфизм ("много форм") — это способность объектов разных классов отвечать на один и тот же запрос по-разному.

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    
    def area(self):
        return 0.5 * self.base * self.height

# Полиморфизм в действии
shapes = [
    Circle(5),
    Rectangle(4, 6),
    Triangle(3, 7)
]

# Все объекты имеют метод area(), но результаты разные
for shape in shapes:
    print(f"Площадь: {shape.area()}")
    # Площадь: 78.5
    # Площадь: 24
    # Площадь: 10.5

4. Абстракция (Abstraction)

Абстракция — это скрывание сложных деталей, показывая только необходимый интерфейс.

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    """Абстрактный класс для обработки платежей"""
    
    @abstractmethod
    def process_payment(self, amount):
        """Каждый обработчик платежей должен реализовать это"""
        pass
    
    @abstractmethod
    def refund(self, transaction_id, amount):
        pass

class CreditCardProcessor(PaymentProcessor):
    def process_payment(self, amount):
        # Сложная логика работы с карточками
        return f"Платёж {amount}$ обработан через карту"
    
    def refund(self, transaction_id, amount):
        return f"Возврат {amount}$ по транзакции {transaction_id}"

class PayPalProcessor(PaymentProcessor):
    def process_payment(self, amount):
        # Другая логика для PayPal
        return f"Платёж {amount}$ обработан через PayPal"
    
    def refund(self, transaction_id, amount):
        return f"Возврат {amount}$ через PayPal"

# Код работает с абстракцией, не зная деталей
def checkout(processor: PaymentProcessor, amount: float):
    return processor.process_payment(amount)

card = CreditCardProcessor()
paypal = PayPalProcessor()

print(checkout(card, 99.99))      # Карта
print(checkout(paypal, 99.99))    # PayPal

Преимущества ООП

✅ Модульность — код разбит на отдельные классы ✅ Переиспользуемость — через наследование и композицию ✅ Поддерживаемость — проще найти и исправить ошибки ✅ Масштабируемость — легче добавлять новую функциональность ✅ Аналогия с реальностью — классы отражают реальные сущности

Недостатки ООП

❌ Сложность — требует более абстрактного мышления ❌ Overengineering — можно переусложнить простые задачи ❌ Производительность — небольшой overhead в сравнении с процедурным кодом

ООП vs Функциональное программирование

# ООП подход
class Calculator:
    def __init__(self):
        self.result = 0
    
    def add(self, x):
        self.result += x
        return self.result
    
    def multiply(self, x):
        self.result *= x
        return self.result

calc = Calculator()
print(calc.add(5))        # 5
print(calc.multiply(3))   # 15

# Функциональный подход
def add(x, y):
    return x + y

def multiply(x, y):
    return x * y

result = multiply(add(0, 5), 3)  # 15

Когда использовать ООП

✅ Большие приложения с множеством сущностей ✅ Долгосрочные проекты, требующие поддержки ✅ Когда нужна переиспользуемость компонентов ✅ Командная разработка

❌ Маленькие скрипты и утилиты ❌ Обработка данных и анализ ❌ Простые системы обработки

ООП — это мощный инструмент для организации больших систем, но не серебряная пуля. Идеальное решение часто комбинирует ООП с функциональным подходом.