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

Да ты послушай, что за ёперный театр творится в этом ООП! Инкапсуляция, блядь — это как если бы ты свою квартиру наглухо закрыл, а вместо двери оставил маленькое окошко, как в тюремной камере. И кричишь оттуда: «Хочешь что-то передать — сувай через это окошко, по правилам! А самому лезть ко мне в хату — нихуя!»

Суть, бля, в чём: Это один из четырёх китов, на которых всё ООП стоит. Смысл — спрятать свои внутренние движухи (поля) и прикрутить к ним ровно те методы, которые с ними работают, в один класс. И сделать так, чтобы снаружи к твоим внутренностям нельзя было просто так, с бухты-барахты, доебаться.

Зачем это надо, ёпта? Чтобы не было пиздопроебищны в коде.

1. Данные защищаешь от кривых рук. Представь, что любой ушлёпок может твоему банковскому счёту баланс на -1000000 выставить. Доверия ебать ноль к таким.
2. Меняешь внутреннюю кухню класса, а весь остальной код даже не чихнёт. Снаружи все пользуются тем же окошком, а у тебя внутри хоть баланс в копейках храни, хоть в биткоинах.
3. Объектом пользоваться проще — тебе не надо знать, как там у него всё устроено в жопе. Знаешь кнопки (методы) — и жми.

Как это делается, хитрая жопа?

• Модификаторы доступа (private, protected, public): Это как уровни доступа. Private — это только для своих, внутри класса. Public — всем желающим, welcome.
• Геттеры и сеттеры: Ну это классика, бля. Прямой доступ к полю закрыл, а сделал методы getПоле() и setПоле(). Через них уже можно и значение проверить, и логику какую-то впендюрить.

Смотри, как это выглядит на Java, чувак:

public class BankAccount {
    // Приватные поля — это наше святое, внутрь не лезть. Прячем, как золото.
    private String accountNumber;
    private double balance;

    // Конструктор публичный — чтобы объект создать могли.
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Геттер для баланса. Посмотреть можно, а тронуть — нет.
    public double getBalance() {
        return balance;
    }

    // Метод для пополнения. Тут мы умные, проверяем, что сумма положительная.
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            throw new IllegalArgumentException("Ты чё, мудила, отрицательную сумму суёшь?!");
        }
    }

    // Метод для снятия. Главное — чтобы не ушёл в минус, а то **будет вам хиросима**.
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false; // Не вышло, иди работай
    }
    // Сеттера для balance НЕТУ! Нельзя просто так взять и изменить баланс. Вот и вся защита.
}

// Использование
BankAccount account = new BankAccount("12345", 1000.0);
// account.balance = 1000000; // Ошибка компиляции! Поле private, **хуй тебе, а не доступ**.
double currentBalance = account.getBalance(); // Окей, смотрим
account.deposit(500.0); // Окей, кладём
boolean success = account.withdraw(2000.0); // Вернёт false, потому что денег нет, **ни хуя себе** снятие.

Инкапсуляция и сокрытие данных — не одно и то же, бля! Сокрытие — это цель (спрятать данные), а инкапсуляция — это способ, как это сделать (засунуть всё в класс и навесить модификаторы). Хотя все их в одну кучу месят.

А без этого что? Да полный пиздец, чувак! Представь, ты в двадцати местах кода напрямую обращаешься к account.balance. А потом бац — и понимаешь, что баланс надо хранить не в рублях, а в копейках (int). И пошёл ты теперь нахуй по всем этим двадцати местам, всё переписывать. А с инкапсуляцией ты просто меняешь логику внутри getBalance() и deposit() — и всё, остальной код даже не заметит, волнение ебать нулевое. Красота!