What is the meaning of encapsulation in object-oriented programming?

Encapsulation is a fundamental principle of OOP, which involves combining data (fields) and methods that work with this data into a single entity — an object. The internal state of the object is hidden from the outside world, and access to it is only through a public interface (public methods).

The purpose of encapsulation is as follows:

• Data protection: Prevents direct modification of the object's internal state from outside, ensuring its integrity and consistency.
• Flexibility and extensibility: Allows changing the internal implementation of the object without affecting the external code that uses this object. For example, you can change the way data is stored or the algorithm of a method without disrupting the rest of the program.
• Simplification of maintenance: Hiding implementation details reduces system complexity, making the code more understandable and easier to support. Developers can work with the object without knowing all its internal nuances.
• Modularity: Objects become independent modules, which facilitates code reuse and the development of large systems.

Example in Java:

public class Account {
    private double balance; // Private field - hidden state

    public Account(double initialBalance) {
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            this.balance = 0;
        }
    }

    public void deposit(double amount) { // Public method - interface for changing state
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) { // Another public method for changing state
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() { // Public method for retrieving state
        return balance;
    }
}

In this example, the balance field is declared as private, making it inaccessible directly from outside the Account class. Interaction with this state occurs only through the public methods deposit(), withdraw(), and getBalance(). This guarantees that the balance will always be non-negative and only changed through predefined operations.