What is encapsulation in programming used for?

Encapsulation in programming is needed for:

1. Data Hiding: Hiding the internal implementation of an object from the outside world. The user interacts with the object through a public interface without direct access to internal data and implementation details. This protects data from unauthorized access and modification.

2. Access Control: Defining which parts of the object are accessible from outside and which are not. In Java, this is implemented using access modifiers: public, protected, default (package-private), and private.

3. Simplifying object usage: The user does not need to know how the object works internally to use it. It is enough to understand the public interface.

4. Increasing flexibility: The ability to change the internal implementation of an object without changing its public interface. This allows improving or modifying the code without affecting the code that uses this object.

5. Reducing complexity: Decomposing a complex system into smaller, encapsulated parts makes the system easier to understand, maintain, and debug.

Example in Java:

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

    public Account(double initialBalance) { // Constructor - public
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            this.balance = 0; // Set default value
        }
    }

    public double getBalance() { // Getter - public
        return balance;
    }

    public void deposit(double amount) { // Setter/method - public, controls modification
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposit completed. Current balance: " + balance);
        } else {
            System.out.println("Deposit amount must be positive.");
        }
    }

    public void withdraw(double amount) { // Setter/method - public, controls modification
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawal completed. Current balance: " + balance);
        } else if (amount > balance) {
            System.out.println("Insufficient funds.");
        } else {
            System.out.println("Withdrawal amount must be positive.");
        }
    }

    // Method that can be used inside the class but not outside
    private void logTransaction(String type, double amount) {
        System.out.println("Transaction: " + type + ", Amount: " + amount);
    }
}

// Usage of the class from outside
public class Main {
    public static void main(String[] args) {
        Account myAccount = new Account(1000.0);

        // Direct access to balance is prohibited (private)
        // myAccount.balance = 2000.0; // Compilation error

        // Access through public methods
        System.out.println("Initial balance: " + myAccount.getBalance()); // Get balance
        myAccount.deposit(500.0); // Deposit
        myAccount.withdraw(200.0); // Withdrawal

        // Attempting incorrect actions is controlled by methods
        myAccount.withdraw(1500.0); // Insufficient funds
        myAccount.deposit(-100.0); // Deposit amount must be positive.
    }
}

In this example, the balance field is private and not directly accessible from outside. Interaction with the balance occurs only through the public methods getBalance, deposit, and withdraw, which control permissible operations and can perform additional logic (checks, logging). This demonstrates all the listed advantages of encapsulation.