What is the difference between public, protected, package-private and private in Java?

ID : 140

viewed : 111

Tags : javaprivatepublicprotectedaccess-modifiersjava

Top 5 Answer for What is the difference between public, protected, package-private and private in Java?

vote vote


The official tutorial may be of some use to you.

Class Package Subclass
(same pkg)
(diff pkg)
public + + + + +
protected + + + +
no modifier + + +
private +

+ : accessible
blank : not accessible

vote vote


(Caveat: I am not a Java programmer, I am a Perl programmer. Perl has no formal protections which is perhaps why I understand the problem so well :) )


Like you'd think, only the class in which it is declared can see it.

Package Private

It can only be seen and used by the package in which it was declared. This is the default in Java (which some see as a mistake).


Package Private + can be seen by subclasses or package members.


Everyone can see it.


Visible outside the code I control. (While not Java syntax, it is important for this discussion).

C++ defines an additional level called "friend" and the less you know about that the better.

When should you use what? The whole idea is encapsulation to hide information. As much as possible you want to hide the detail of how something is done from your users. Why? Because then you can change them later and not break anybody's code. This lets you optimize, refactor, redesign, and fix bugs without worrying that someone was using that code you just overhauled.

So, the rule of thumb is to make things only as visible as they have to be. Start with private and only add more visibility as needed. Only make public that which is necessary for the user to know, every detail you make public cramps your ability to redesign the system.

If you want users to be able to customize behaviors, rather than making internals public so they can override them, it's often a better idea to shove those guts into an object and make that interface public. That way they can simply plug in a new object. For example, if you were writing a CD player and wanted the "go find info about this CD" bit customizable, rather than make those methods public you'd put all that functionality into its object and make just your object getter/setter public. In this way being stingy about exposing your guts encourages good composition and separation of concerns

I stick with just "private" and "public". Many OO languages just have that. "Protected" can be handy, but it's a cheat. Once an interface is more than private it's outside of your control and you have to go looking in other people's code to find uses.

This is where the idea of "published" comes in. Changing an interface (refactoring it) requires that you find all the code which is using it and change that, too. If the interface is private, well no problem. If it's protected you have to go find all your subclasses. If it's public you have to go find all the code which uses your code. Sometimes this is possible, for example, if you're working on corporate code that's for internal use only it doesn't matter if an interface is public. You can grab all the code out of the corporate repository. But if an interface is "published", if there is code using it outside your control, then you're hosed. You must support that interface or risk breaking code. Even protected interfaces can be considered published (which is why I don't bother with protected).

Many languages find the hierarchical nature of public/protected/private to be too limiting and not in line with reality. To that end, there is the concept of a trait class, but that's another show.

vote vote


Here's a better version of the table, that also includes a column for modules.

Java Access Modifiers


  • A private member (i) is only accessible within the same class as it is declared.

  • A member with no access modifier (j) is only accessible within classes in the same package.

  • A protected member (k) is accessible within all classes in the same package and within subclasses in other packages.

  • A public member (l) is accessible to all classes (unless it resides in a module that does not export the package it is declared in).

Which modifier to choose?

Access modifiers is a tool to help you to prevent accidentally breaking encapsulation(*). Ask yourself if you intend the member to be something that's internal to the class, package, class hierarchy or not internal at all, and choose access level accordingly.


  • A field long internalCounter should probably be private since it's mutable and an implementation detail.
  • A class that should only be instantiated in a factory class (in the same package) should have a package restricted constructor, since it shouldn't be possible to call it directly from outside the package.
  • An internal void beforeRender() method called right before rendering and used as a hook in subclasses should be protected.
  • A void saveGame(File dst) method which is called from the GUI code should be public.

(*) What is Encapsulation exactly?

vote vote


____________________________________________________________________                 | highest precedence <---------> lowest precedence *———————————————+———————————————+———————————+———————————————+———————  \ xCanBeSeenBy | this          | any class | this subclass | any   \__________   | class         | in same   | in another    | class              \  | nonsubbed     | package   | package       |     Modifier of x \ |               |           |               |        ————————————————*———————————————+———————————+———————————————+——————— public          |       ✔       |     ✔     |       ✔       |   ✔   ————————————————+———————————————+———————————+———————————————+——————— protected       |       ✔       |     ✔     |       ✔       |   ✘    ————————————————+———————————————+———————————+———————————————+——————— package-private |               |           |               | (no modifier)   |       ✔       |     ✔     |       ✘       |   ✘    ————————————————+———————————————+———————————+———————————————+——————— private         |       ✔       |     ✘     |       ✘       |   ✘     ____________________________________________________________________ 
vote vote


Easy rule. Start with declaring everything private. And then progress towards the public as the needs arise and design warrants it.

When exposing members ask yourself if you are exposing representation choices or abstraction choices. The first is something you want to avoid as it will introduce too many dependencies on the actual representation rather than on its observable behavior.

As a general rule I try to avoid overriding method implementations by subclassing; it's too easy to screw up the logic. Declare abstract protected methods if you intend for it to be overridden.

Also, use the @Override annotation when overriding to keep things from breaking when you refactor.

Top 3 video Explaining What is the difference between public, protected, package-private and private in Java?