Access modifiers

Written Explanation

Two small previews

Package. A package is a named group of related classes. In a project it corresponds to a folder, and the first line of a source file declares it, for example package bank;. Classes in the same package live side by side. You will learn packages properly later; for now, "same package" means "same group".

Subclass. A class can be built on top of another class and reuse it (this is called inheritance, taught later). The new class is the subclass. For this lesson, treat a subclass as "a relative of the class".

The four levels

The Java tutorial lists the levels from most to least open. Here they are from the most closed, which is the order you should think in.

Each row includes everything the row above it allows: every level is at least as open as the one before.

• private: usable only inside the class that declares it. The vault.
• Package-private: what you get when you write no modifier at all. Usable by any class in the same package. The back office. The Java Language Specification calls this package access and says it is the default for most declarations.
• protected: same package, plus subclasses even when they are in other packages. The partner desk.
• public: usable from anywhere the class itself can be seen. The window.

A top-level class (one not written inside another class) can be only public or package-private. private and protected apply to members: fields, methods, and constructors.

The same class always has full access

Inside the class, everything is visible, whatever its level. A private field is as easy to use in the class's own methods as a public one. Levels only restrict other code.

A worked example

Here is an Account in package bank with one member at each level:

package bank;

public class Account {
    private double balance;           // only Account
    String branch = "Central";        // package-private: package bank
    protected String note = "none";   // package bank + subclasses
    public String owner;              // everywhere
    // constructor and methods follow
}

(In real code you would not make owner public; this is only a demonstration. Lesson 4 returns to it.)

A class in a different package, with no relation to Account, tries to use every member:

System.out.println(a.branch);
System.out.println(a.note);
System.out.println(a.balance);
System.out.println(a.fee(10));   // fee is a private method

error: branch is not public in Account; cannot be accessed from outside package
error: note has protected access in Account
error: balance has private access in Account
error: fee(double) has private access in Account

Only owner was usable. A class in package bank could use branch and note too. A subclass of Account in another package can use note but not branch.

Choosing a level: the rule

The Java tutorial advises using the most restrictive level that makes sense, and private unless there is a specific reason. Turn that into a short checklist:

1. Fields: private. Almost always. The previous lesson showed why.
2. Helper methods that exist only to help one method of the class: private. Nobody else should depend on them, so you stay free to rename or delete them.
3. Methods other classes are meant to call, your teller-window operations such as deposit and withdraw: public.
4. Methods meant to be used or overridden by subclasses, but not by the general public: protected.
5. Things shared only by closely related classes in one package: package-private. Do this on purpose, not by forgetting a keyword (a later lesson in this course covers this "forgotten modifier").

If you cannot decide, pick the more restrictive level. Opening a member later is easy: no existing code can break. Closing a member later is hard: code somewhere may already use it.

A note on constructors and classes

The same four levels apply to constructors. A private constructor means "nobody outside may create this object". Classes declared with no modifier are visible only inside their package. For now, make the classes you want others to use public.