Why use getters and setters/accessors for private vars, instead of making vars public?

on

 

Using getters and setters (accessors and mutators) for private variables instead of making variables public provides better control over the encapsulation and behavior of your class, following the principles of encapsulation and data hiding in object-oriented programming. This approach allows you to enforce validation, control access, and make changes to the internal implementation without affecting the external interface of your class. Let's look at an example to understand this better:

java
public class BankAccount {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double newBalance) {
        if (newBalance >= 0) {
            balance = newBalance;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.setBalance(1000.0); // Using setter to set the balance

        double balance = account.getBalance(); // Using getter to retrieve the balance
        System.out.println("Account balance: " + balance);
    }
}

In this example, the BankAccount class encapsulates the balance variable, making it private. Instead of directly accessing or modifying the balance variable, we use getter and setter methods. This encapsulation allows you to add validation and control over how the balance is modified. The setBalance method ensures that the balance can only be set to a non-negative value.

Benefits of using getters and setters:

  1. Encapsulation: You hide the implementation details and provide a controlled interface to access and modify the internal state of the class.

  2. Validation: You can enforce rules and validation checks before allowing modifications to the internal state.

  3. Flexibility: If you later need to modify the internal representation of the data (for example, adding logging or auditing), you can do so without changing the external code that uses the class.

  4. Maintainability: Changes to the internal representation or behavior are localized within the class, minimizing the impact on other parts of the codebase.

  5. Abstraction: The class can present a higher-level abstraction to the user, decoupling them from the implementation details.

In contrast, making variables public allows direct access and modification, which can lead to unforeseen issues if not managed properly. By using getters and setters, you maintain control over the data and ensure that the class remains consistent and robust as your codebase evolves.

Comments

Post a Comment