Что такое инкапсуляция?

Что такое инкапсуляция?

Инкапсуляция — это один из четырёх основных принципов объектно-ориентированного программирования (ООП). Это механизм скрытия внутренней реализации объекта и предоставления контролируемого доступа к его данным через публичные методы.

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

Инкапсуляция объединяет данные (состояние) и методы (поведение) в один объект и скрывает внутренние детали реализации от внешнего мира. Доступ к данным происходит только через чётко определённые интерфейсы.

Принципы инкапсуляции

1. Скрытие данных — приватные атрибуты класса (private/protected)
2. Контролируемый доступ — публичные методы (getters/setters)
3. Валидация — проверка корректности данных при установке
4. Инвариантность — гарантия логической консистентности объекта

Пример без инкапсуляции (плохо)

class BankAccount:
    balance = 0  # Публичный атрибут

account = BankAccount()
account.balance = -1000  # Любой может установить отрицательный баланс!

Пример с инкапсуляцией (хорошо)

class BankAccount:
    def __init__(self, initial_balance: float):
        self.__balance = initial_balance  # Приватный атрибут
    
    def deposit(self, amount: float) -> None:
        """Пополнить счёт"""
        if amount > 0:
            self.__balance += amount
        else:
            raise ValueError("Сумма должна быть положительной")
    
    def withdraw(self, amount: float) -> None:
        """Снять со счёта"""
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            raise ValueError("Недостаточно средств")
    
    def get_balance(self) -> float:
        """Получить баланс"""
        return self.__balance

# Использование
account = BankAccount(1000)
account.deposit(500)  # OK
print(account.get_balance())  # 1500
account.withdraw(200)  # OK
# account.__balance = -999  # ОШИБКА: AttributeError

Уровни доступа

Python:

• public_attr — публичный атрибут (по конвенции)
• _protected_attr — защищённый (одно подчёркивание, по конвенции)
• __private_attr — приватный (двойное подчёркивание, name mangling)

Другие языки (Java, C++):

• public — доступен везде
• protected — доступен в классе и наследниках
• private — доступен только в классе

Свойства (Properties) в Python

class User:
    def __init__(self, email: str):
        self._email = email
        self._age = 0
    
    @property
    def email(self) -> str:
        """Getter для email"""
        return self._email
    
    @email.setter
    def email(self, value: str) -> None:
        """Setter для email с валидацией"""
        if '@' in value:
            self._email = value
        else:
            raise ValueError("Некорректный email")
    
    @property
    def age(self) -> int:
        return self._age
    
    @age.setter
    def age(self, value: int) -> None:
        if 0 <= value <= 150:
            self._age = value
        else:
            raise ValueError("Некорректный возраст")

# Использование
user = User("john@example.com")
user.email = "john.doe@example.com"  # Выглядит как присваивание, но вызывает setter
user.age = 25
print(user.email)  # john.doe@example.com

Преимущества инкапсуляции

1. Безопасность данных — защита от некорректного использования
2. Гибкость — можно менять внутреннюю реализацию без изменения интерфейса
3. Валидация — проверка данных при вводе
4. Упрощение тестирования — контролируемый доступ к состоянию
5. Снижение связанности — объекты не зависят от внутренней структуры друг друга

Инкапсуляция в Data Engineering

Пример с обработкой данных:

class DataPipeline:
    def __init__(self):
        self.__errors = []  # Приватный список ошибок
        self.__processed_count = 0
    
    def process(self, data: list) -> None:
        """Обработать данные"""
        for item in data:
            try:
                self.__validate(item)
                self.__processed_count += 1
            except ValueError as e:
                self.__errors.append(str(e))
    
    def __validate(self, item) -> None:
        """Приватный метод валидации"""
        if not item:
            raise ValueError("Пустой элемент")
    
    def get_statistics(self) -> dict:
        """Публичный интерфейс для статистики"""
        return {
            'processed': self.__processed_count,
            'errors': len(self.__errors),
            'error_log': self.__errors[:10]  # Ограниченная информация
        }

Связь с другими принципами ООП

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

Когда НЕ переусложнять инкапсуляцию

Правило YAGNI (You Aren't Gonna Need It):

• Начни с публичных атрибутов
• Сделай их приватными, когда появляется необходимость валидации
• Не предусматривай проблемы заранее

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