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

Инкапсуляция — один из основных принципов ООП

Что такое инкапсуляция простыми словами?

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

Аналогия из жизни:

• Когда вы едите в машине, вы нажимаете педаль газа
• Вы не видите, как работает двигатель, карбюратор, электроника
• Все сложное спрятано внутри
• Вам нужно знать только: педаль газа = ускорение

Это инкапсуляция — сложность скрыта внутри, а снаружи простой интерфейс.

Три уровня доступа в ООП

1. Private (Приватное)

Данные доступны только внутри самого класса.

class BankAccount:
    def __init__(self):
        self.__balance = 0  # Приватный атрибут
    
    def deposit(self, amount):
        # Только внутри класса можно менять balance
        if amount > 0:
            self.__balance += amount

Примеры:

• account.__balance = 1000000 — ОШИБКА, нельзя снаружи
• Только метод deposit() может увеличить баланс

Почему это важно?

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

2. Protected (Защищенное)

Данные доступны внутри класса и в наследующих классах.

class User:
    def __init__(self):
        self._password = "secret"  # Защищено (одно подчеркивание)

class Admin(User):
    def reset_password(self):
        # Можно использовать _password из родителя
        self._password = "newpass"

Условность: это соглашение, Python не блокирует доступ, но разработчики договариваются не трогать _variable.

3. Public (Публичное)

Данные доступны всем.

class Person:
    def __init__(self):
        self.name = "John"  # Публичное
        self.age = 30       # Публичное

user = Person()
print(user.name)  # OK
user.name = "Jane"  # OK

Свойства и методы (Properties)

Инкапсуляция работает через методы (getters и setters):

class Temperature:
    def __init__(self):
        self.__celsius = 0
    
    def get_celsius(self):
        return self.__celsius
    
    def set_celsius(self, value):
        if -273 <= value <= 1000:  # Проверка
            self.__celsius = value
        else:
            raise ValueError("Invalid temperature")

temp = Temperature()
temp.set_celsius(25)    # OK
temp.set_celsius(-500)  # ERROR!

В Python есть удобный способ через @property:

class Temperature:
    def __init__(self):
        self.__celsius = 0
    
    @property
    def celsius(self):
        return self.__celsius
    
    @celsius.setter
    def celsius(self, value):
        if -273 <= value <= 1000:
            self.__celsius = value
        else:
            raise ValueError("Invalid temperature")

temp = Temperature()
temp.celsius = 25      # Выглядит как обычное присваивание
print(temp.celsius)    # Выглядит как обычное чтение

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

Пример 1: API токен

class AuthService:
    def __init__(self):
        self.__api_token = None
    
    def login(self, username, password):
        # Внутренняя проверка
        if not self._validate_credentials(username, password):
            return False
        self.__api_token = self._generate_token()  # Приватный
        return True
    
    def make_request(self, endpoint):
        # Используем приватный токен
        headers = {"Authorization": f"Bearer {self.__api_token}"}
        return requests.get(endpoint, headers=headers)

Что мы тестируем:

• Невозможно вручную установить неправильный токен
• Все запросы идут с корректным токеном
• Токен недоступен снаружи (security)

Пример 2: Корзина покупок

class ShoppingCart:
    def __init__(self):
        self.__items = []  # Приватный список
        self.__total = 0   # Приватная сумма
    
    def add_item(self, item, price):
        # Проверка перед добавлением
        if price < 0:
            raise ValueError("Price cannot be negative")
        self.__items.append({"item": item, "price": price})
        self.__total += price
    
    def get_total(self):
        return self.__total  # Только чтение
    
    def clear(self):
        self.__items = []
        self.__total = 0

Что мы тестируем:

• Невозможно добавить отрицательную цену
• Total всегда соответствует сумме добавленных товаров
• Невозможно вручную установить total = 0 после добавления товаров
• Clear очищает все правильно

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

1. Защита от неправильного использования

# БЕЗ инкапсуляции
user.password = ""  # Ошибка, но возможна
user.balance = -1000  # Ошибка, но возможна

# С инкапсуляцией
user.set_password("")  # Метод проверит и вернет ошибку
user.set_balance(-1000)  # Метод проверит и вернет ошибку

2. Легко менять внутреннюю реализацию

# Версия 1
class User:
    def __init__(self):
        self.__password = "raw_password"

# Версия 2 (позже)
class User:
    def __init__(self):
        self.__password_hash = hash("password")  # Хешируем
        self.__salt = generate_salt()

# Внешний код ничего не изменил! Все работает благодаря инкапсуляции

3. Безопасность

Приватные атрибуты типа пароля, токена, API ключа не доступны снаружи.

4. Контроль доступа

Мы решаем, кто может читать/писать данные.

Для QA: Что тестировать?

1. Проверка валидации

# Тест: нельзя установить отрицательный возраст
def test_cannot_set_negative_age():
    user = User()
    with pytest.raises(ValueError):
        user.set_age(-5)

2. Проверка консистентности

# Тест: баланс всегда консистентен с операциями
def test_balance_consistency():
    account = BankAccount()
    account.deposit(100)
    account.deposit(50)
    account.withdraw(30)
    
    assert account.get_balance() == 120
    assert account.get_balance() == 100 + 50 - 30  # Проверяем

3. Проверка изоляции

# Тест: приватные данные не доступны снаружи
def test_private_data_inaccessible():
    user = User()
    
    # Не должно быть доступно
    with pytest.raises(AttributeError):
        _ = user.__password

4. Проверка побочных эффектов

# Тест: изменение через один метод не сломает другие
def test_method_isolation():
    user = User()
    user.set_email("new@email.com")
    
    # Email изменился
    assert user.get_email() == "new@email.com"
    # Но остальное не сломалось
    assert user.get_username() == "original_username"

Инкапсуляция в разных языках

Java:

public class BankAccount {
    private double balance;  // РЕАЛЬНО приватно
    
    public void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
}

Python:

class BankAccount:
    def __init__(self):
        self.__balance = 0  # Условно приватно

JavaScript:

class BankAccount {
    #balance = 0;  // Реально приватно (ES2022)
    
    deposit(amount) {
        if (amount > 0) this.#balance += amount;
    }
}

Типичные ошибки без инкапсуляции

1. Нарушение целостности данных

   • user.balance = -999999 (хакер себе денег добавил)

2. Сложность при изменении кода

   • Менять внутреннюю структуру опасно, так как много кода зависит от этого

3. Трудность при рефакторинге

   • Невозможно переписать логику без поломки всего

4. Уязвимости безопасности

   • Критичные данные доступны снаружи

Заключение

Инкапсуляция — это не просто "спрячь данные", это:

• Защита от неправильного использования
• Контроль целостности данных
• Безопасность
• Возможность менять внутреннюю реализацию без влияния на внешний код

Для QA это означает:

• Тестировать валидацию при попытке установить неправильные значения
• Проверять консистентность данных
• Убеждаться, что приватные данные действительно защищены
• Проверять граничные случаи для каждого метода