What are Java's access modifiers?

Question

Accepted Answer

**Access modifiers** control the **visibility** of classes, methods, and fields — who can access them. They're the mechanism behind encapsulation. Java has four levels, from most to least restrictive.

## The four levels

```java
public class Example {
    public int a;        // accessible from ANYWHERE
    protected int b;     // same package + SUBCLASSES (even in other packages)
    int c;               // package-private (DEFAULT, no keyword) — same package only
    private int d;       // accessible ONLY within THIS class
}
```

## The visibility table

```text
Modifier      Same class  Same package  Subclass (other pkg)  Everywhere
────────────────────────────────────────────────────────────────────────
public            ✓            ✓                ✓                  ✓
protected         ✓            ✓                ✓                  ✗
(default)         ✓            ✓                ✗                  ✗
private           ✓            ✗                ✗                  ✗
```

Note: omitting a modifier gives **package-private** (default) — visible within the same package only. This is a distinct level, not the same as public.

## How they enable encapsulation

```java
public class BankAccount {
    private double balance;          // hidden — protect the data

public void deposit(double amt) { // public API — controlled access
        if (amt > 0) balance += amt;
    }
    public double getBalance() {      // read-only access to private data
        return balance;
    }
}
// outside code CANNOT do account.balance = -1000 (it's private)
```

The standard pattern: make fields **`private`** and expose controlled **`public`** methods. This protects invariants and lets you change the internal representation without breaking callers — the essence of encapsulation.

## Practical guidance

```text
✓ Fields → private (almost always); expose via methods if needed
✓ Public API methods → public
✓ Internal helpers → private
✓ For subclasses to access/override → protected
✓ Classes → public (usable anywhere) or package-private (internal to a module)
```

The principle: use the **most restrictive** modifier that still works (least privilege) — start private and open up only as needed.

## Why it matters

Access modifiers are how Java implements **encapsulation** — the foundational OOP principle of hiding internal details and exposing controlled interfaces.

Choosing the right modifier (defaulting to `private` for fields, `public` only for intended API) protects data integrity, prevents external code from depending on internals (so you can refactor freely), and makes a class's intended usage clear.

Understanding all four levels — especially the often-forgotten package-private default and the subclass-spanning `protected` — is essential for designing well-encapsulated, maintainable classes and APIs, and for controlling how much of your code is exposed to the rest of a system.