{"id":5271,"date":"2021-03-23T16:33:53","date_gmt":"2021-03-23T16:33:53","guid":{"rendered":"https:\/\/ded9.com\/?p=5271"},"modified":"2025-12-09T10:56:52","modified_gmt":"2025-12-09T10:56:52","slug":"java-access-level-controllers-training-in-plain-language","status":"publish","type":"post","link":"https:\/\/ded9.com\/de\/java-access-level-controllers-training-in-plain-language\/","title":{"rendered":"What Is Java Access Level Controllers \u2014 Understanding Java\u2019s Access Modifiers"},"content":{"rendered":"

In this tutorial, you will learn about the different types of\u00a0Java access Modifiers<\/span><\/a><\/span> and how they work in various scenarios.<\/span><\/span><\/p>\n

What is an Access Modifier?<\/span><\/h2>\n

Access level controllers are keywords that determine the accessibility (access rate) of a class, interface, variable, data member, method, or constructor.\u00a0They are also known as visibility modifiers.<\/p>\n

You can encapsulate the code using access level adjusters. This means specifying what part of a program can access class members. Therefore, data misuse can be prevented.<\/p>\n

Types of access level adjusters- Access Modifiers in Java<\/h2>\n

Access level adjusters inside the package<\/h3>\n

A package container collects different and related types (Java classes, interfaces, counting, and annotations).<\/p>\n

Four keywords regulate access levels in Java<\/a>:<\/p>\n

\"Four<\/p>\n

All access level regulators are described in detail below.<\/p>\n

1. Default access level<\/span><\/h3>\n

If the access level regulator is not explicitly specified for a class, variable, method, or constructor, the access level defaults to the default.<\/p>\n

Example 1: Define the default access level<\/p>\n

\n
    \n
  1. package defaultPackage;<\/li>\n
  2. class Logger {<\/li>\n
  3. void message () {<\/li>\n
  4. System.out.println (\u201cThis is a message\u201d);<\/li>\n
  5. }<\/li>\n
  6. }<\/li>\n<\/ol>\n<\/blockquote>\n

    Here, the Logger class has a default access level and is available to classes in the defaultPackage package. You will get an error if you import the Logger class in different packages and try to use it.<\/p>\n

    2- Private access level<\/span><\/h3>\n

    Only data members and methods can be declared private; classes or interfaces cannot. However, internal classes in the nested class can be declared private.<\/p>\n

    You can access private variables outside the class if the class has public receiver methods.<\/p>\n

    Example 2: Define a private access level<\/strong><\/p>\n

    \n
      \n
    1. public class Data {<\/li>\n
    2. private String name;<\/li>\n
    3. public String getName () {<\/li>\n
    4. return this.name;<\/li>\n
    5. }<\/li>\n
    6. public void setName (String name) {<\/li>\n
    7. this.format = name;<\/li>\n
    8. }<\/li>\n
    9. }<\/li>\n
    10. public class Main {<\/li>\n
    11. Public static void main (String [] main) {<\/li>\n
    12. Data d = new Data ();<\/li>\n
    13. d.setName (“Programming”);<\/li>\n
    14. System.out.println (d.getName ());<\/li>\n
    15. }<\/li>\n
    16. }<\/li>\n<\/ol>\n<\/blockquote>\n

      Output<\/strong><\/p>\n

      \n

      Programiz<\/p>\n<\/blockquote>\n

      Here, name is a private variable and is only accessible within the Data class.\u00a0However, with the help of public receiver methods, it can be accessed in the Main class.<\/p>\n

      3- Access level protected<\/span><\/h3>\n

      The protected access level provides access to the same package and classes that are direct subclasses of your base class. Data members and methods can be protected, whereas classes or interfaces cannot.<\/p>\n

      Example 3: Define a protected access level<\/strong><\/p>\n

      \n
        \n
      1. \/\/ Logger.java<\/li>\n
      2. package package1;<\/li>\n
      3. public class Logger {<\/li>\n
      4. protected void debug (String logLine) {<\/li>\n
      5. System.out.println (“Debug line:” + logLine);<\/li>\n
      6. }<\/li>\n
      7. }<\/li>\n
      8. \/\/ Main.java<\/li>\n
      9. package package2;<\/li>\n
      10. import package1.Logger;<\/li>\n
      11. public class Main extends Logger {<\/li>\n
      12. public static void main (String [] args) {<\/li>\n
      13. Main logger = new Main ();<\/li>\n
      14. \/\/ invokes debug () from Logger class<\/li>\n
      15. logger.debug (\u201chello from main\u201d);<\/li>\n
      16. }<\/li>\n
      17. }<\/li>\n<\/ol>\n<\/blockquote>\n

        Output<\/strong><\/p>\n

        \n

        Debug line: hello from main<\/p>\n<\/blockquote>\n

        Logger.java and Main.java are in different packages. The debug() method in the Logger class is protected and accessible only within the package. However, it is also available in the Main class because Main inherits from Logger.<\/p>\n

        4- Public access level<\/span><\/h3>\n

        The unlimited public access level applies to classes and interfaces, including methods, data members, and variables.<\/p>\n

        Example 4: Define the public access level<\/strong><\/p>\n

        \n
          \n
        1. \/\/ Logger.java<\/li>\n
        2. public class Logger {<\/li>\n
        3. public int debugLevel = 1;<\/li>\n
        4. public void debug (String logLine) {<\/li>\n
        5. System.out.println (“Debug:” + logLine);<\/li>\n
        6. }<\/li>\n
        7. public void info (String logLine) {<\/li>\n
        8. System.out.println (“Info:” + logLine);<\/li>\n
        9. }<\/li>\n
        10. }<\/li>\n
        11. \/\/ LoggerImp.java<\/li>\n
        12. public class LoggerImp {<\/li>\n
        13. public static void main (String [] args) {<\/li>\n
        14. Logger logger = new Logger ();<\/li>\n
        15. logger.debug (\u201cdebug with level\u201d + logger.debugLevel);<\/li>\n
        16. logger.debugLevel = 5;<\/li>\n
        17. logger.info (\u201cinfo with level\u201d + logger.debugLevel);<\/li>\n
        18. }<\/li>\n
        19. }<\/li>\n<\/ol>\n<\/blockquote>\n

          Output<\/strong><\/p>\n

          \n

          Debug: debug with level 1<\/p>\n

          Info: info with level 5<\/p>\n<\/blockquote>\n

          Here, in the LoggerImp class, you were able to create a Logger instance because Logger is public. Variables and methods within the LoggerImp class are also public. Hence, you can use it directly in the LoggerImp class.<\/p>\n

          \"Here,<\/p>\n

          The TestE<\/code> class, base subclass, allows access to the protected members TestB<\/code> through inheritance. However, invoking a protected superclass method directly will result in a compile-time error.<\/p>\n

          Java access modifiers are straightforward once you grasp the basics. It’s important not to mix up default and protected access levels. A helpful tip: default access is more restrictive than protected access, because protected members can be accessed within subclasses.<\/p>\n