Java Access Modifiers — private, default, protected, public

Direct Answer

Java has four access levels: private (inside the declaring top-level class and its nested members), package-private or default (same package), protected (same package plus limited access from subclasses in other packages), and public (wherever the declaring type is accessible). Top-level classes can be only public or package-private.

Code Example

Seeing all four modifiers in one class makes the spectrum concrete. Each field below carries the narrowest access it can tolerate, and the methods expose only what the outside world legitimately needs.

package com.company.model;

public class BankAccount {
    private double balance;       // only BankAccount can access
    String accountNumber;          // default: same package only
    protected String ownerName;    // same package + subclasses anywhere
    public String bankName;        // accessible everywhere

    public void deposit(double amount) {  // public API
        if (amount > 0) balance += amount; // only this class touches balance
    }

    protected double getBalance() {       // subclasses can call this
        return balance;
    }
}

Notice the logic behind each choice: balance is the most sensitive value so it is private, while bankName is shared freely as public. The modifier on every line is really a one-word statement of who is allowed to depend on that member.

Common Mistakes & Pitfalls

• Reading "default" as more open than protected — default actually blocks subclasses in other packages, while protected lets them in; getting this backwards is exactly the trap interviewers set.
• Treating package-private as the same as public — a default member is invisible outside its package, so code in another module that used it as if it were public will not even compile.
• Making fields public for convenience — once external code reads account.balance directly, you can never add validation or change the representation without breaking every caller.
• Assuming private is only "partly" restrictive — private is absolute; not even a subclass in the same file can see it, so reaching for protected when you meant private quietly widens your public surface.