19.11. Encapsulation: Error Handling

Encapsulation is one of the fundamental concepts in object-oriented programming. It is used to hide an object's data values ​​or states, preventing direct user access. This is called data hiding. Encapsulation ensures data integrity as it can only be manipulated through methods. Error handling is a crucial part of encapsulation.

Understanding Encapsulation

In simple terms, encapsulation is the process of hiding implementation details and showing only the functionality to the user. In other words, it is a way to protect data from direct access. In encapsulation, the variables of a class will always be hidden from other classes. They can only be accessed through the methods of their own class.

Error Handling in Encapsulation

Error handling is a crucial part of encapsulation. Without good error handling, a failure in one method can have undesired effects elsewhere in the program, which can be difficult to debug. Furthermore, without good error handling, a program can give the user misleading information or even fail in ways that are difficult to predict.

There are several ways to handle errors in a program. A common way is to use exceptions. An exception is an event that occurs during program execution that interrupts the normal flow of instructions. When an exception occurs, the program transfers control to a suitable exception handler, a block of code designed to handle the error in some way.

Encapsulation and Error Handling Example

Let's consider a simple example of encapsulation and error handling. Suppose we have a class called 'BankAccount' with two fields, 'AccountNumber' and 'Balance'. We want 'balance' to always be positive and 'accountnumber' to always be a valid account number. To ensure this, we can encapsulate these fields and provide methods to set their values, where we can check the conditions before setting the values.

class BankAccount {
    private int numberAccount;
    private double balance;

    public void setAccountNumber(int AccountNumber) {
        if (accountnumber > 0) {
            this.accountnumber = accountNumber;
        } else {
            throw new IllegalArgumentException("Invalid account number!");
        }
    }

    public void deposit(double amount) {
        if (value > 0) {
            this.balance += value;
        } else {
            throw new IllegalArgumentException("Invalid deposit amount!");
        }
    }

    public void withdraw(double value) {
        if (value > 0 && value <= this.balance) {
            this.balance -= value;
        } else {
            throw new IllegalArgumentException("Invalid withdrawal amount!");
        }
    }
}

In the example above, we encapsulate the fields 'accountnumber' and 'balance' and provide methods to set their values. In these methods, we check the conditions before setting the values. If the conditions are not met, we throw an exception with an appropriate error message. This ensures that the 'accountnumber' and 'balance' fields always have valid values ​​and therefore maintains data integrity.

Conclusion

In summary, encapsulation is an effective way to protect data from direct access and ensure data integrity. Error handling is a crucial part of encapsulation, as it helps prevent program failures and provides the user with accurate information. Therefore, it is essential to understand and correctly apply encapsulation and error handling when writing programs.