Какие знаешь теории инкапсуляции?

Теории инкапсуляции

Инкапсуляция — один из фундаментальных принципов объектно-ориентированного программирования. За годы опыта я столкнулся с несколькими подходами к её реализации в Python и других языках.

1. Классическая инкапсуляция (Data Hiding)

Идея состоит в том, чтобы скрыть внутреннее состояние объекта и предоставить контролируемый доступ через методы.

# ❌ Плохо — прямой доступ к полям
class BankAccount:
    def __init__(self, balance):
        self.balance = balance  # Можно менять напрямую

account = BankAccount(1000)
account.balance = -1000  # Некорректное состояние!

# ✅ Хорошо — инкапсуляция с методами
class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # Приватное поле
    
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Сумма должна быть положительной")
        self._balance += amount
    
    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Сумма должна быть положительной")
        if amount > self._balance:
            raise ValueError("Недостаточно средств")
        self._balance -= amount
    
    def get_balance(self):
        return self._balance

account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
print(account.get_balance())  # 1300

2. Инкапсуляция в Python — соглашения vs строгие правила

В Python нет строгого механизма приватности, как в Java или C++. Вместо этого используются соглашения:

class Account:
    def __init__(self, balance):
        self._balance = balance  # Protected (соглашение)
        self.__pin = "1234"      # Private (name mangling)
    
    def get_balance(self):
        return self._balance
    
    def __check_pin(self, pin):  # Private метод
        return pin == self.__pin
    
    def verify(self, pin):
        if self.__check_pin(pin):
            return True
        raise ValueError("Неверный PIN")

# Работает, но это соглашение
account = Account(1000)
print(account._balance)  # 1000 — доступно, но "не трогайте"

# Name mangling затрудняет доступ, но не запрещает
print(account._Account__pin)  # "1234" — всё равно можно достать

# Это словно говорит: "я знаю что делаю, но учтите последствия"

3. Property Decorator — "умная" инкапсуляция

Позволяет объявить получение и установку данных как свойства:

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        """Getter"""
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        """Setter с валидацией"""
        if value < -273.15:
            raise ValueError("Абсолютный ноль")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        """Вычисляемое свойство"""
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

temp = Temperature(25)
print(temp.celsius)      # 25
print(temp.fahrenheit)   # 77.0

temp.fahrenheit = 86     # Автоматический пересчёт
print(temp.celsius)      # 30

# Синтаксис как обычный атрибут, но с контролем
temp.celsius = -300      # ValueError: Абсолютный ноль

4. Инкапсуляция через класс-обёртку

Добавляем слой абстракции для сложной логики:

class SecureString:
    def __init__(self, value):
        self._value = value
        self._encrypted = False
    
    def encrypt(self):
        if not self._encrypted:
            self._value = hash(self._value)
            self._encrypted = True
    
    def is_encrypted(self):
        return self._encrypted
    
    def __repr__(self):
        return "SecureString(***)"

password = SecureString("my_password")
password.encrypt()
print(password)  # SecureString(***)

# Внешний код не видит реальное значение

5. Инкапсуляция данных в Dataclass

Modern подход с автоматической генерацией методов:

from dataclasses import dataclass, field
from typing import List

@dataclass
class User:
    name: str
    email: str
    age: int = 0
    _tags: List[str] = field(default_factory=list, init=False, repr=False)
    
    def add_tag(self, tag: str):
        """Контролируемое добавление тега"""
        if tag and len(tag) < 50:
            self._tags.append(tag)
    
    def get_tags(self):
        return list(self._tags)  # Копия, не оригинал
    
    def __post_init__(self):
        if self.age < 0 or self.age > 150:
            raise ValueError("Некорректный возраст")

user = User("Alice", "alice@example.com", 30)
user.add_tag("developer")
print(user.get_tags())  # ['developer']

# Нельзя создать User с некорректным возрастом
try:
    User("Bob", "bob@example.com", -5)
except ValueError as e:
    print(e)

6. Инкапсуляция через Protocol (Duck Typing)

Python подход — не важна точный тип, важно что объект может делать:

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> None: ...

class Circle:
    def draw(self):
        print("●")

class Square:
    def draw(self):
        print("■")

def render(shape: Drawable):
    """Работает с любым объектом, у которого есть draw()"""
    shape.draw()

render(Circle())   # ●
render(Square())   # ■

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

7. Инкапсуляция состояния в классе (Encapsulation Pattern)

Объект отвечает за свой инвариант:

class ShoppingCart:
    def __init__(self):
        self._items: dict[str, tuple[float, int]] = {}  # name -> (price, quantity)
        self._total = 0.0
    
    def add_item(self, name: str, price: float, quantity: int = 1):
        if price < 0 or quantity <= 0:
            raise ValueError("Некорректные параметры")
        
        if name in self._items:
            old_qty = self._items[name][1]
            self._items[name] = (price, old_qty + quantity)
        else:
            self._items[name] = (price, quantity)
        
        self._recalculate_total()
    
    def remove_item(self, name: str):
        if name in self._items:
            del self._items[name]
            self._recalculate_total()
    
    def _recalculate_total(self):
        """Приватный метод — гарантирует консистентность"""
        self._total = sum(price * qty for price, qty in self._items.values())
    
    def get_total(self):
        return self._total
    
    def get_items(self):
        return dict(self._items)  # Копия

cart = ShoppingCart()
cart.add_item("Apple", 1.5, 3)
cart.add_item("Banana", 0.5, 2)
print(cart.get_total())  # 5.5

# Невозможно нарушить инвариант
cart._total = 1000  # Можно, но это работает вопреки коду
print(cart.get_items())  # Реальные данные не совпадают с total

8. Инкапсуляция побочных эффектов

Объект контролирует взаимодействие с внешним миром:

class Logger:
    def __init__(self, filename):
        self._filename = filename
        self._file = None
        self._buffer = []
    
    def log(self, message: str):
        self._buffer.append(message)
        if len(self._buffer) >= 10:
            self.flush()
    
    def flush(self):
        with open(self._filename, 'a') as f:
            for msg in self._buffer:
                f.write(msg + "\n")
        self._buffer.clear()
    
    def __del__(self):
        """Гарантирует flush при удалении"""
        if self._buffer:
            self.flush()

logger = Logger("app.log")
logger.log("Starting app")
logger.log("Loading data")
# Файл записывается только когда нужно (batch optimization)

9. Инкапсуляция в многопоточности

Объект должен быть потокобезопасен:

from threading import Lock

class ThreadSafeCounter:
    def __init__(self):
        self._value = 0
        self._lock = Lock()
    
    def increment(self):
        with self._lock:
            self._value += 1
    
    def get_value(self):
        with self._lock:
            return self._value
    
    # Lock инкапсулирован, пользователь не видит его

counter = ThreadSafeCounter()
# Пользователь не должен знать о существовании Lock
counter.increment()
print(counter.get_value())

10. Инкапсуляция в контексте зависимостей

Объект скрывает свои зависимости:

class UserService:
    def __init__(self, db_connection, cache, logger):
        self._db = db_connection       # Инкапсулируем зависимость
        self._cache = cache
        self._logger = logger
    
    def get_user(self, user_id: int):
        # Клиент не знает о кэше или логировании
        cached = self._cache.get(f"user:{user_id}")
        if cached:
            return cached
        
        self._logger.debug(f"Fetching user {user_id} from DB")
        user = self._db.fetch_one("SELECT * FROM users WHERE id = %s", user_id)
        
        if user:
            self._cache.set(f"user:{user_id}", user, ttl=3600)
        
        return user

service = UserService(db, cache, logger)
user = service.get_user(42)
# Реализация деталей скрыта

Основные принципы инкапсуляции

1. Скрывайте детали реализации — пользователи должны знать только интерфейс
2. Гарантируйте инварианты — объект отвечает за свое состояние
3. Минимальный интерфейс — предоставляйте только необходимое
4. Контролируйте доступ — любое изменение состояния должно быть валидировано
5. Скрывайте зависимости — пользователь не должен знать о внутренних деталях
6. Изолируйте сложность — внешний API должен быть простым
7. Гарантируйте потокобезопасность — если нужно
8. Версионируйте интерфейсы — менее заметны изменения внутренней реализации

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