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

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

Инкапсуляция - один из трех столпов объектно-ориентированного программирования (наряду с наследованием и полиморфизмом). Это один из самых важных принципов, который часто недопонимают разработчики.

Определение

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

Это не просто о private/public. Это о контроле доступа и разделении интерфейса и реализации.

Суть инкапсуляции

Ключевая идея: разделение публичного контракта от приватной реализации.

class BankAccount {
private:
    double balance;          // Скрыто - внутреннее состояние
    
    // Приватный метод для внутреннего использования
    void validateAmount(double amount) {
        if (amount <= 0) {
            throw std::invalid_argument("Amount must be positive");
        }
    }
    
public:
    // Публичный контракт
    void deposit(double amount) {
        validateAmount(amount);
        balance += amount;
    }
    
    bool withdraw(double amount) {
        validateAmount(amount);
        if (balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    double getBalance() const {
        return balance;
    }
};

Внешний код может только:

• Вызвать deposit()
• Вызвать withdraw()
• Получить getBalance()

Он НЕ может:

• Напрямую изменить balance (например, balance = 1000000)
• Обойти валидацию
• Нарушить инварианты класса

Три уровня доступа в C++

class Vehicle {
public:                              // Доступно везде
    void accelerate() { /* ... */ }
    
protected:                           // Доступно в классе и наследниках
    void updateSpeed() { /* ... */ }
    
private:                             // Доступно только в этом классе
    double speed;
    void internalCalibration() { /* ... */ }
};

// Снаружи
Vehicle car;
car.accelerate();              // OK
// car.updateSpeed();           // Ошибка!
// car.speed = 100;             // Ошибка!
// car.internalCalibration();   // Ошибка!

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

// ПЛОХО - без инкапсуляции
struct BankAccountBad {
    double balance;  // public по умолчанию
};

int main() {
    BankAccountBad acc;
    acc.balance = 1000;
    
    // Кто-то может нарушить правила:
    acc.balance = 1000000;           // Просто так!
    acc.balance = -999;              // Отрицательный баланс?
    acc.balance = 0.1234567890123;   // Точность нарушена?
    
    // Никаких гарантий!
}

С инкапсуляцией мы гарантируем, что такое невозможно.

Инварианты класса

Инкапсуляция защищает инварианты - свойства, которые всегда должны быть истины:

class Date {
private:
    int day, month, year;
    
    // Инварианты:
    // 1 <= day <= 31
    // 1 <= month <= 12
    // year > 0
    
    void validate() {
        if (day < 1 || day > 31) throw std::invalid_argument("Invalid day");
        if (month < 1 || month > 12) throw std::invalid_argument("Invalid month");
        if (year <= 0) throw std::invalid_argument("Invalid year");
    }
    
public:
    Date(int d, int m, int y) : day(d), month(m), year(y) {
        validate();
    }
    
    // Инварианты сохраняются!
};

// Невозможно создать дату 32 апреля
Date invalid(32, 4, 2024);  // Выброс исключения

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

1. Гибкость реализации

// Версия 1: vector
class StudentList {
private:
    std::vector<Student> students;
    
public:
    void addStudent(const Student& s) { students.push_back(s); }
    int getCount() const { return students.size(); }
    Student getStudent(int index) const { return students[index]; }
};

// Версия 2: linked list (без изменения публичного интерфейса!)
class StudentList {
private:
    std::list<Student> students;  // Изменили реализацию
    
public:
    void addStudent(const Student& s) { students.push_back(s); }  // Точно так же
    int getCount() const { return students.size(); }
    Student getStudent(int index) const { /* преобразование индекса */ }
};

// Клиентский код не изменился!

2. Контроль побочных эффектов

class Temperature {
private:
    double celsius;
    
public:
    void setCelsius(double c) {
        if (c < -273.15) throw std::invalid_argument("Below absolute zero");
        celsius = c;
        notifyObservers();  // Побочный эффект контролируется
        updateUI();
        logChange(c);
    }
};

// vs

struct TemperatureBad {
    double celsius;  // Прямое изменение - нет контроля
};

3. Версионирование API

class User {
private:
    std::string email;
    std::string phone;
    
public:
    // Версия 1
    void setEmail(const std::string& e) { email = e; }
    std::string getEmail() const { return email; }
    
    // Версия 2 - добавили валидацию
    void setEmail(const std::string& e) {
        if (!isValidEmail(e)) throw std::invalid_argument("Invalid email");
        email = e;
        notifyChanged();
    }
};

// Публичный интерфейс остался прежним
// Поведение улучшилось - это OK
// Благодаря инкапсуляции мы можем это сделать

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

class FileHandle {
private:
    FILE* handle;
    bool isOpen;
    
public:
    FileHandle(const std::string& path) {
        handle = fopen(path.c_str(), "r");
        isOpen = (handle != nullptr);
    }
    
    // Нельзя случайно удалить файл
    void read(std::string& content) {
        if (!isOpen) throw std::runtime_error("File not open");
        // Безопасное чтение
    }
    
    ~FileHandle() {
        if (handle) fclose(handle);  // Автоматическое закрытие
    }
};

Инкапсуляция vs Скрытие информации

Важно различать эти два понятия:

// Это скрытие информации (hiding), но НЕ инкапсуляция
class BadEncapsulation {
private:
    int internalState;
    
public:
    int getInternalState() const { return internalState; }
    void setInternalState(int s) { internalState = s; }
};
// Просто getter/setter - не является инкапсуляцией
// Любой может установить любое значение
// Инварианты не защищены

// Это правильная инкапсуляция
class GoodEncapsulation {
private:
    int processedValue;
    
    void validate(int val) {
        if (val < 0 || val > 100) throw std::invalid_argument("Out of range");
    }
    
public:
    void setValue(int val) {
        validate(val);
        processedValue = val;
        updateDependents();
    }
    
    int getValue() const { return processedValue; }
};
// Логика и защита инвариантов

Инкапсуляция в иерархии классов

class Shape {  // Базовый класс
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
    
protected:
    // Защищено для наследников
    void validateDimensions() { /* ... */ }
    
private:
    // Только для Shape
    void internalCache() { /* ... */ }
};

class Circle : public Shape {
private:
    double radius;
    
public:
    double area() const override {
        validateDimensions();  // OK - protected
        return 3.14159 * radius * radius;
    }
};

// Вне класса:
Shape* s = new Circle();
s->area();                 // OK - public
// s->validateDimensions();  // Ошибка - protected

Best Practices

1. Принцип наименьших привилегий

// ХОРОШО: минимум доступа
class Calculator {
private:
    double add(double a, double b) { return a + b; }
    double multiply(double a, double b) { return a * b; }
    
public:
    double calculate(const std::string& expression) {
        // Использует приватные методы
    }
};

// ПЛОХО: слишком много public
class CalculatorBad {
public:
    double add(double a, double b) { return a + b; }
    double multiply(double a, double b) { return a * b; }
    // Все может вызвать что угодно
};

2. Immutability где возможно

class Configuration {
private:
    const std::string configPath;
    const std::map<std::string, std::string> values;
    
public:
    Configuration(const std::string& path) 
        : configPath(path), values(loadConfig(path)) {}
    
    const std::string& getValue(const std::string& key) const {
        return values.at(key);
    }
    // Нет setters - конфигурация неизменяема
};

3. RAII для управления ресурсами

class Database {
private:
    Connection* connection;
    
public:
    Database(const std::string& dsn) {
        connection = new Connection(dsn);
        connection->open();
    }
    
    ~Database() {
        if (connection) {
            connection->close();
            delete connection;  // Контроль жизненного цикла
        }
    }
};

Заключение

Инкапсуляция - это не просто private/public. Это о:

• Защите инвариантов - гарантия, что объект всегда в валидном состоянии
• Контроле интерфейса - определение, что можно делать с объектом
• Гибкости реализации - возможность менять внутри без изменения клиентов
• Предотвращении ошибок - невозможность неправильного использования
• Разделении ответственности - класс отвечает за свое состояние

В C++ инкапсуляция реализуется через private/protected/public члены и методы доступа, но суть - в логическом разделении того, что видят пользователи класса, и что скрыто внутри.