Java private Keyword
Usage and Examples

private Keyword in Java

In Java, private is one of the four access modifiers used to restrict the visibility of classes, methods, and variables. It plays a key role in achieving encapsulation—a fundamental principle of object-oriented programming.

When a member is declared private, it can only be accessed within the same class. This helps you protect the internal state of an object and prevent external code from directly modifying it.

Why Use private?

• To safeguard sensitive data from outside access.
• To force controlled access via public getters/setters.
• To prevent misuse or accidental manipulation of internal logic.
• To support encapsulation by exposing only necessary interfaces.

Using private with Variables

Most commonly, you’ll use private to declare instance variables in a class. This keeps them hidden from other classes.

public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public double getBalance() {
        return balance;
    }
}

Explanation

Here, balance is declared private. You can't access it directly from outside the class. Instead, you access it via the public method getBalance(). This is a textbook example of encapsulation.

BankAccount acc = new BankAccount();
acc.balance = 5000; // Compilation error: balance has private access

Using private with Methods

You might want to make some helper methods private if they should not be part of the public API.

public class Validator {
    public boolean isValidUser(String userId) {
        return isInternalUser(userId);
    }

    private boolean isInternalUser(String userId) {
        return userId.startsWith("INT");
    }
}

Explanation

The isInternalUser method is a private helper that checks a specific logic. It’s not meant to be accessed from outside. Making it private ensures that no external class can call it directly.

Validator v = new Validator();
v.isInternalUser("INT123"); // Error: isInternalUser() has private access

Using private with Constructors

In rare cases, constructors can also be declared private—especially in design patterns like Singleton.

public class AppConfig {
    private static AppConfig instance = new AppConfig();

    private AppConfig() {
        // private constructor
    }

    public static AppConfig getInstance() {
        return instance;
    }
}

Explanation

Since the constructor is private, you cannot instantiate AppConfig using new from outside the class. The only way to access the instance is through the getInstance() method. This is how Singleton Pattern works.

AppConfig config = new AppConfig(); // Error: AppConfig() has private access

Access Control Summary

Let’s compare how access modifiers behave in terms of visibility:

Modifier	Same Class	Same Package	Subclass	Other Classes
private	✔	✖	✖	✖
default (no modifier)	✔	✔	✔ (if in same package)	✖
protected	✔	✔	✔	✖
public	✔	✔	✔	✔

Best Practices When Using private

• Keep class variables private and expose them via getters/setters.
• Minimize the visibility of your class members—start with private and increase only when needed.
• Use private methods to clean up public methods and hide implementation details.