Access Modifiers in Java

Access modifiers in Java control who can see and use your classes, fields, methods, and constructors. There are four levels: private, default, protected, and public. Using them well is how you stop other code from breaking your objects.

What are access modifiers in Java?

An access modifier is a keyword you put in front of a declaration to set its visibility. Think of an office building: some rooms are open to the public, some only to staff, and some only to one person with the key.

Java access modifiers table: who can see what?

This table shows each modifier's visibility. Read across a row to see where that modifier lets code reach:

Notice the pattern: each level down the table opens one more "door".

private double balance;

double balance;   // no modifier

protected void onDeposit(double amount) { }

public void deposit(double amount) { }

The private modifier

private members can only be used by code inside the same class. This is the right default for fields. Other classes then have to go through your methods, where you can check the values:

public class BankAccount {
    private double balance;          // nobody outside can touch this directly

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Deposit must be positive");
        }
        balance += amount;
    }

    public double getBalance() {     // read-only access from outside
        return balance;
    }
}

BankAccount acc = new BankAccount();
acc.deposit(100);
System.out.println(acc.getBalance());   // 100.0
acc.balance = -5000;                     // ✘ compile error: balance has private access

This pattern, with private fields and public methods that guard them, is called encapsulation. It's one of the most important habits in Java.

The default (package-private) modifier

If you write no modifier, the member is visible to every class in the same package. A package is a folder-like group of related classes, declared with package com.example.bank; at the top of a file.

package com.example.bank;

class InterestCalculator {           // only classes in com.example.bank can use this
    double monthlyRate(double yearlyRate) {
        return yearlyRate / 12;
    }
}

The protected modifier

protected is like default access, plus one extra door: subclasses in other packages can use it through inheritance.

package com.example.bank;

public class Account {
    protected double balance;
}

// ---- different file, different package ----
package com.example.savings;

import com.example.bank.Account;

public class SavingsAccount extends Account {
    public void addInterest(double rate) {
        balance += balance * rate;   // ✔ allowed: SavingsAccount inherits balance
    }
}

The public modifier

public means any code can use it. Make public only what other classes are meant to call. That's your class's API (its public "menu"). Everything else should stay hidden.

Where can each modifier be used?

How do you choose the right access modifier?

A simple rule of thumb that professional Java developers follow:

1. Make fields private, almost always.
2. Make methods public only if other classes need to call them.
3. Use default for helper classes that belong to one package.
4. Use protected only when you're deliberately designing for subclasses.

Quick recap

What's next?

You've seen protected work with subclasses. Now learn how subclasses work in inheritance in Java, or review classes and objects.