Java - Access Modifiers

Java provides a number of access modifiers to set access levels for classes, variables, methods, and constructors.

Java provides a number of access modifiers to set access levels for classes, variables, methods, and constructors. The four access levels are −

  • Visible to the package, the default. No modifiers are needed.
  • Visible to the class only (private).
  • Visible to the world (public).
  • Visible to the package and all subclasses (protected).
  • Default Access Modifier - No Keyword

    Default access modifier means we do not explicitly declare an access modifier for a class, field, method, etc.


    Variables and methods can be declared without any modifiers
    There are following example
    String version = "1.5.1";
    boolean processOrder() {
       return true;

    Private Access Modifier - Private

    Methods, variables, and constructors that are declared private can only be accessed within the declared class itself.
    Private access modifier is the most restrictive access level. Class and interfaces cannot be private.


    There are following class uses private access control
    public class Logger {
       private String format;
       public String getFormat() {
          return this.format;
       public void setFormat(String format) {
          this.format = format;

    Here, the format variable of the Logger class is private, so there's no way for other classes to retrieve or set its value directly.

    So, to make this variable available to the outside world, we defined two public methods: getFormat(), which returns the value of format, and setFormat(String), which sets its value.

    Public Access Modifier - Public

    A class, method, constructor, interface, etc. declared public can be accessed from any other class. Therefore, fields, methods, blocks declared inside a public class can be accessed from any class belonging to the Java Universe.


    The following function uses public access control −

    The main() method of an application has to be public. But it could not be called by a Java interpreter (such as java) to run the class.

    Protected Access Modifier - Protected

    Variables, methods, and constructors, which are declared protected in a superclass can be accessed only by the subclasses in other package or any class within the package of the protected members' class.

    Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it.


    The following parent class uses protected access control, to allow its child class override openSpeaker() method
    class AudioPlayer {
       protected boolean openSpeaker(Speaker sp) {
          // implementation details
    class StreamingAudioPlayer {
       boolean openSpeaker(Speaker sp) {
          // implementation details