What Are the Access Modifiers in Java?

In Java, access modifiers are keywords that define the visibility and accessibility of classes, methods, and variables. These modifiers determine the scope and accessibility of components in different parts of the code. The access modifiers in Java control how and where we can access classes, methods, and fields. There are four types of access modifiers in Java:

• Public
• Private
• Protected
• Default (no modifier)

Understanding these access modifiers and when to use them is crucial for designing robust, secure, and maintainable applications. Let’s dive deeper into each modifier and see how they work with practical code examples.

1. Public Access Modifier

The public access modifier allows the member (variable, method, or class) to be accessible from anywhere in the program. It can be accessed by any other class, whether it is within the same package or a different package.

  class PublicExample {
      public int number;

      public void displayNumber() {
          System.out.println("Number: " + number);
      }
  }

  public class TestPublic {
      public static void main(String[] args) {
          PublicExample obj = new PublicExample();
          obj.number = 10;  // Accessible because it's public
          obj.displayNumber();  // Accessible because it's public
      }
  }
  

In the above example, the PublicExample class has a public variable number and a public method displayNumber(). Both the variable and method can be accessed from the TestPublic class in the same or different package.

2. Private Access Modifier

The private access modifier restricts the visibility of a member to only the class in which it is defined. No other class can access or modify private members. It is used to protect sensitive data and ensure that certain components are not directly accessible from outside the class.

  class PrivateExample {
      private int number;

      private void displayNumber() {
          System.out.println("Number: " + number);
      }

      public void setNumber(int number) {
          this.number = number;
      }

      public void showNumber() {
          displayNumber(); // Private method can be called within the same class
      }
  }

  public class TestPrivate {
      public static void main(String[] args) {
          PrivateExample obj = new PrivateExample();
          // obj.number = 10;  // Compilation error: number has private access
          obj.setNumber(10);  // Can access through public setter method
          obj.showNumber();  // Can access private method through public method
      }
  }
  

Here, the variable number and method displayNumber() are private and cannot be accessed directly from outside the class. However, public getter and setter methods can be used to interact with private data, demonstrating the encapsulation principle.

3. Protected Access Modifier

The protected access modifier allows access to members from within the same package or subclasses (even if they are in different packages). It provides a middle ground between public and private access, allowing subclasses to inherit and access protected members, but limiting access from other unrelated classes.

  class ProtectedExample {
      protected int number;

      protected void displayNumber() {
          System.out.println("Number: " + number);
      }
  }

  class SubclassExample extends ProtectedExample {
      public void showNumber() {
          number = 10;  // Accessible because it's protected
          displayNumber();  // Accessible because it's protected
      }
  }

  public class TestProtected {
      public static void main(String[] args) {
          SubclassExample obj = new SubclassExample();
          obj.showNumber();  // Can access protected method and variable through subclass
      }
  }
  

In the example above, the variable number and method displayNumber() are protected. They can be accessed from the SubclassExample class because it extends the ProtectedExample class. If you were to try to access them from a non-subclass outside the package, it would result in a compilation error.

4. Default Access Modifier (Package-Private)

If no access modifier is specified, it is considered the default access level, also known as package-private. Members with default access can only be accessed by other classes in the same package. They are not accessible from outside the package.

  class DefaultExample {
      int number;  // Default access

      void displayNumber() {  // Default access
          System.out.println("Number: " + number);
      }
  }

  public class TestDefault {
      public static void main(String[] args) {
          DefaultExample obj = new DefaultExample();
          obj.number = 10;  // Accessible because it's in the same package
          obj.displayNumber();  // Accessible because it's in the same package
      }
  }
  

In the above code, the DefaultExample class has a default member number and a default method displayNumber(). These can be accessed because the TestDefault class is in the same package. However, if TestDefault were in a different package, it would not be able to access the DefaultExample class members.

Conclusion

Access modifiers are an essential feature of Java that provide control over the accessibility of classes, methods, and variables. By using these modifiers appropriately, developers can ensure that their code remains secure, maintainable, and easy to understand. Here’s a quick summary of the four access modifiers:

• Public: Accessible from anywhere.
• Private: Accessible only within the same class.
• Protected: Accessible within the same package or by subclasses.
• Default (Package-Private): Accessible only within the same package.

When designing a Java application, it’s essential to use these access modifiers correctly to ensure proper encapsulation, security, and maintainability of the codebase. By understanding and implementing access modifiers, you can control the scope of your components, making your program more robust and easier to maintain.