Java With Us

The <code>private</code> Access Modifier in Java

Updated on 2026-04-21 Reviewed by the Java With Us editorial team

private is the most restrictive access modifier in Java. A private member is visible only inside the declaring class — not subclasses, not the same package, not reflection (without setAccessible(true)).

Where to use it

  • Default for fields — encapsulation means hiding state behind methods.
  • Helper methods inside a class — implementation detail, not part of the public API.
  • Constructors of utility classes and singletons (prevent instantiation).
  • Nested classes used only by the outer class.

Example

public class BankAccount {
    private final String owner;
    private BigDecimal balance;

    public BankAccount(String owner) { this.owner = owner; balance = BigDecimal.ZERO; }
    public void deposit(BigDecimal amount) {
        validate(amount);
        balance = balance.add(amount);
    }

    private void validate(BigDecimal amount) {      // internal helper
        if (amount.signum() <= 0) throw new IllegalArgumentException();
    }
}

Private in interfaces (Java 9+)

public interface Logger {
    default void info(String m)  { log("INFO",  m); }
    default void error(String m) { log("ERROR", m); }
    private void log(String level, String m) {      // shared helper, hidden from implementers
        System.out.println("[" + level + "] " + m);
    }
}

What it doesn't protect against

  • Reflection — field.setAccessible(true) bypasses it. Java modules can block this.
  • Serialisation — fields are written/read as raw bytes unless marked transient.
  • Lombok and friends — annotation processors can synthesise public accessors. That's intentional.

Top-level classes can't be private

Only nested and inner classes can. For a top-level class, use package-private (no keyword).

Common mistakes

  • Public fields — bypasses encapsulation entirely.
  • Package-private by default — if only the declaring class needs access, use private.
  • Protected fields as a default — breaks encapsulation for subclasses. Expose via protected methods, keep fields private.

Related

Pillar: Java access modifiers. See also public, encapsulation.

Related articles