OOP Encapsulation | Encapsulation principle and use case

The principle of encapsulation is one of the basic principles of object-oriented programming and involves hiding the internal implementation of an object from the outside world. This means that the data and the methods that operate on that data are combined into a single entity called a class.

External code can only interact with an object through certain interfaces provided by the class, without having direct access to its internal data.

Benefits of the Encapsulation Principle

Data encapsulation has many practical applications in software development. Here are some usage examples encapsulation on practice:

1. Data security. Encapsulation allows you to protect the data of an object from incorrect access and modification from the outside. A class can only provide certain methods (getters and setters) for accessing data that validate operations and ensure data security.
2. Implementation hiding. When a class encapsulates its implementation, changes within the class are not reflected in external code. This allows you to change the implementation of the object without breaking the functionality of the client code, which makes it easier to maintain and evolve the program.
3. Simplification of the interface. Encapsulation allows you to provide a simple and understandable interface for working with objects. The client code interacts only with the public methods of the class, without requiring knowledge of the details of its internal implementation.
4. Modularity. Encapsulation helps to create modular systems, where each class is a separate module with its own data and methods. Modules can interact with each other through public interfaces, which improves the readability and understandability of the code.
5. Single responsibility principle. Encapsulation promotes the Single Responsibility Principle. A class that encapsulates certain data and operations on it should only be responsible for that data and its processing.
6. Access control. OOP encapsulation allows you to set access levels to data and methods of a class. Thus, some data and functionality can be hidden from other classes or packages, which helps to protect and control the code.

Applying the encapsulation process to your programming practice helps you create more structured, secure, and extensible code. It facilitates better management of program complexity and facilitates collaboration between developers when developing large projects.

An example of encapsulation in OOP

Consider encapsulation with a simple example:

    public class BankAccount {
    private String accountNumber; // Закрытое поле для номера счета
    private double balance; // Закрытое поле для баланса счета

    // Конструктор класса
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Метод для получения номера счета (getter)
    public String getAccountNumber() {
        return accountNumber;
    }

    // Метод для получения баланса счета (getter)
    public double getBalance() {
        return balance;
    }

    // Метод для внесения денег на счет
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    // Метод для снятия денег со счета
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

In the example above, the class BankAccount encapsulates bank account data (accountNumber And balance) and provides an interface for working with them. fields accountNumber And balance announced as privatewhich makes them only available within the class.

To access account data from outside the class, public methods (getters and setters) are used. In this case, methods getAccountNumber() And getBalance() allow you to get the account number and balance, respectively. And the methods deposit() And withdraw() provide an opportunity to deposit or withdraw money from the account.

So external code can use the object BankAccount, knowing only the public methods, not the internal implementation details of the class. This allows you to safely change the internal implementation of the class BankAccountwithout affecting the code that interacts with it.

Read also about the principle of abstraction in OOP.