Access modifiers

Who changed the balance?

What are access modifiers?

Words you'll meet in this lesson

The access table (learn this one)

Where each level is used

And private: the default choice for fields. Everything not needed outside the class should be private.

Private members inside one file

class Account {
    private int balance = 5000;      // only Account's own code can use this
    int branchCode = 7;              // default: any class in this package

    public int getBalance() {        // read-only window
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account acc = new Account();
        System.out.println(acc.getBalance());   // OK: public method
        System.out.println(acc.branchCode);     // OK: same package (same file)
        // System.out.println(acc.balance);     // error: balance has private access in Account
    }
}

One field, four modifiers: what compiles and what prints

The best way to learn the table is to run it. Here is a small project with two packages. Class bank.Account has one field, ifsc. Five classes try to read it from different places. We will change only the modifier on ifsc and see, each time, which classes compile and how the output changes.

src/
├── bank/
│   ├── Account.java    declares ifsc
│   └── Branch.java     same package, not a subclass
├── shop/
│   ├── Savings.java    other package, subclass (uses its inherited ifsc)
│   ├── Kiosk.java      other package, not related
│   └── Loan.java       other package, subclass (reads ifsc of a plain Account object)
└── app/
    └── Main.java       calls show() on each class

package bank;

public class Account {
    public String ifsc = "SBIN0001234";   // ← the only word we change

    public void showOwn() {
        System.out.println("1. Account itself     : " + ifsc);
    }
}

package bank;

public class Branch {
    public void show() {
        Account a = new Account();
        System.out.println("2. Branch (same pkg)  : " + a.ifsc);
    }
}

package shop;

import bank.Account;

public class Savings extends Account {
    public void show() {
        System.out.println("3. Savings (subclass) : " + ifsc);   // its own inherited copy
    }
}

package shop;

import bank.Account;

public class Kiosk {
    public void show() {
        Account a = new Account();
        System.out.println("4. Kiosk (other pkg)  : " + a.ifsc);
    }
}

package shop;

import bank.Account;

public class Loan extends Account {
    public void show() {
        Account other = new Account();
        System.out.println("5. Loan (via parent)  : " + other.ifsc);   // someone else's Account
    }
}

Press a modifier below. Every ✓, ✗, error message and output line was produced by the real javac and java. When a class does not compile, the whole build fails, so we leave that class out of Main and run the rest.

package app;

import bank.Account;
import bank.Branch;
import shop.Kiosk;
import shop.Loan;
import shop.Savings;

public class Main {
    public static void main(String[] args) {
        new Account().showOwn();
        new Branch().show();
        new Savings().show();
        new Kiosk().show();
        new Loan().show();
    }
}

package app;

import bank.Account;
import bank.Branch;
import shop.Savings;

public class Main {
    public static void main(String[] args) {
        new Account().showOwn();
        new Branch().show();
        new Savings().show();
    }
}

package app;

import bank.Account;
import bank.Branch;

public class Main {
    public static void main(String[] args) {
        new Account().showOwn();
        new Branch().show();
    }
}

package app;

import bank.Account;

public class Main {
    public static void main(String[] args) {
        new Account().showOwn();
    }
}

How the output changes: the whole experiment in one table

Read the table column by column: every step down from public to private removes one more group of users. That is exactly the access table above, now with real output.

Methods and constructors follow exactly the same rules. Change ifsc to a method getIfsc() and every ✓ and ✗ stays the same.

Private constructors

final class GstUtil {
    private GstUtil() { }                      // nobody can create a GstUtil object

    static int gst(int price) { return price * 18 / 100; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(GstUtil.gst(500));
        // new GstUtil();   // error: GstUtil() has private access in GstUtil
    }
}

How javac checks an access

1. Find the member being used

   int b = acc.balance;

   javac resolves acc's type (bank.Account) and finds the field balance and its modifier.

2. Compare where the code is with where the member is declared

   The using code is in class shop.Report; the member is declared in class bank.Account. Different class, different package, and Report is not a subclass of Account.

3. Apply the table

   private requires the same class: ✗. javac reports balance has private access in Account and writes no class file.

4. The JVM checks again when linking

   If someone edits bytecode or compiles against an old version of Account, the JVM still refuses with IllegalAccessError at run time. Access control is part of Java's security, not just a compile-time hint.

5. Reflection can bypass it, with permission

   Field f = Account.class.getDeclaredField("balance");
   f.setAccessible(true);   // frameworks do this for private fields

   Frameworks such as JSON mappers use reflection to read private fields. Since Java 9 the module system can block this for JDK internals. Treat private as “not part of the contract”, not as encryption.

Four accesses, four answers

Left: code in another package trying to use members of bank.Account. Right: javac checking each access against the four levels.

Access control in real systems

Access modifiers are how teams keep large codebases safe to change: what's private can be rewritten freely, what's public must keep working.

Watch it with an example: a hospital record with layers of access

A Patient class in package hospital. Different code in the system asks for different parts of it. The compiler lets each one see only what its access level allows.

Examples are simplified. Since Java 9, modules add another layer: a package is only visible to other modules if its module exports it.

A wallet with private data and public methods

class Wallet {
    private final String owner;
    private int balance;

    public Wallet(String owner, int balance) {
        this.owner = owner;
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public boolean pay(int amount) {
        if (amount <= 0 || amount > balance) {
            return false;
        }
        balance -= amount;
        log("paid " + amount);
        return true;
    }

    private void log(String msg) {
        System.out.println("[" + owner + "] " + msg);
    }
}

public class Main {
    public static void main(String[] args) {
        Wallet w = new Wallet("Riya", 500);
        System.out.println(w.pay(120));
        System.out.println(w.pay(900));
        System.out.println("Left: " + w.getBalance());
    }
}

• private int balanceOnly Wallet's own methods can change it.
• public boolean pay(…)The only way to spend money, and it checks the rules first.
• private void log(…)An internal helper. Outside code can't call it, so it can be changed freely.
• private final String ownerPrivate and never reassigned after the constructor.

Private data changed only through a public method

Access rules are checked by the compiler, so they leave no trace at run time. What you can see is the effect: the only path to the private field goes through methods of its own class.

Worked examples: real problems, solved and traced in memory

Three designs where the right access level does the protecting. Watch the private fields change only inside their own class's methods.

PAN "ABCDE1234F"

PAN: XXXXXX234F

set 85, then try 850

true false marks=85

"9876543210"

+91 98765 43210

Check yourself

Quick revision

Interview and viva questions

Practice problems

Choose the right access level, fix access errors, and design classes with a small public surface. The last three are business tasks.

reading 31

Temp: 31 C

class Sensor {
    private int temperature = 31;

    public int getTemperature() {
        return temperature;
    }
}

public class Main {
    public static void main(String[] args) {
        Sensor s = new Sensor();
        System.out.println("Temp: " + s.getTemperature() + " C");
    }
}

499 then -50

499

class Product {
    private int price;

    public void setPrice(int p) {
        if (p >= 0) {
            price = p;
        }
    }

    public int getPrice() {
        return price;
    }
}

public class Main {
    public static void main(String[] args) {
        Product pen = new Product();
        pen.setPrice(499);
        pen.setPrice(-50);
        System.out.println(pen.getPrice());
    }
}

branch "Kharghar"

Kharghar
Branch: Kharghar

class Branch {
    String city = "Kharghar";
    private String vaultCode = "7731";

    String label() {
        return "Branch: " + city;
    }
}

public class Main {
    public static void main(String[] args) {
        Branch b = new Branch();
        System.out.println(b.city);
        System.out.println(b.label());
    }
}

PNR "8421937750", seat "S4-32"

8421937750 S4-32

class Ticket {
    private final String pnr;
    private final String seat;

    public Ticket(String pnr, String seat) {
        this.pnr = pnr;
        this.seat = seat;
    }

    public String getPnr() { return pnr; }
    public String getSeat() { return seat; }
}

public class Main {
    public static void main(String[] args) {
        Ticket t = new Ticket("8421937750", "S4-32");
        System.out.println(t.getPnr() + " " + t.getSeat());
    }
}

items 99.999 and 50.004

150.0

class Bill {
    private double[] items;

    public Bill(double... items) {
        this.items = items;
    }

    public double total() {
        double t = 0;
        for (double i : items) t += i;
        return round2(t);
    }

    private double round2(double x) {
        return Math.round(x * 100) / 100.0;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Bill(99.999, 50.004).total());
    }
}

code "482913"; user types "482931", then "482913"

false
true

class Otp {
    private final String code;
    private int attemptsLeft = 3;

    public Otp(String code) {
        this.code = code;
    }

    public boolean verify(String typed) {
        if (attemptsLeft == 0) return false;
        attemptsLeft--;
        return code.equals(typed);
    }
}

public class Main {
    public static void main(String[] args) {
        Otp otp = new Otp("482913");
        System.out.println(otp.verify("482931"));
        System.out.println(otp.verify("482913"));
    }
}

role "HR", role "TEAM"

Kavya: Rs 85000
Kavya: hidden

class Employee {
    private final String name;
    private final int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String salaryFor(String role) {
        if (role.equals("HR")) {
            return name + ": Rs " + salary;
        }
        return name + ": hidden";
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e = new Employee("Kavya", 85000);
        System.out.println(e.salaryFor("HR"));
        System.out.println(e.salaryFor("TEAM"));
    }
}

amount 1000, fee 0.5%

UPI ok: Rs 1005 (incl. fee Rs 5)

class UpiAdapter {
    String send(int amount) {
        return "UPI ok: Rs " + amount;
    }
}

public class Main {
    static class PaymentService {
        private final UpiAdapter upi = new UpiAdapter();

        public String pay(int amount) {
            int fee = fee(amount);
            return upi.send(amount + fee) + " (incl. fee Rs " + fee + ")";
        }

        private int fee(int amount) {
            return amount * 5 / 1000;
        }
    }

    public static void main(String[] args) {
        PaymentService ps = new PaymentService();
        System.out.println(ps.pay(1000));
    }
}

Real-world scenario questions (asked in company interviews)

Access-modifier questions in interviews are really design questions: what should the rest of the system be allowed to depend on?