Java - Access Modifiers

 Access Modifiers in Java

Java Access Modifiers are an essential part of Object-Oriented Programming in Java. They control the accessibility, visibility, and usage scope of classes, methods, variables, and constructors. Understanding access modifiers is extremely important for beginners as well as advanced Java programmers because they directly influence encapsulation, data hiding, inheritance rules, package structure, and API design. Access Modifiers in Java determine how different parts of a program will interact with each other, whether components remain exposed or protected, and how objects behave when used across different classes and packages. The most common Java Access Modifiers are public, private, protected, and the default (no modifier). Each modifier has a specific purpose, level of visibility, and typical use cases in real-world Java applications such as enterprise applications, frameworks, APIs, and secure software engineering.

Types of Access Modifiers in Java

Java provides four types of access modifiers. These modifiers help control where a class member (method, variable, constructor) can be accessed. The four access levels are: public, private, protected, and default (package-private). These access levels help developers apply encapsulation, restrict unauthorized access, improve code maintainability, and follow industry standards for secure programming. Java’s access modifier design is inspired by the principles of abstraction and modular development, which ensures that different modules of an application can interact safely without exposing unnecessary internal implementation details. Understanding each modifier deeply helps programmers design classes that are flexible, reusable, and secure. The upcoming sections explain each modifier in detail with 10–15+ lines and examples.

1. Public Access Modifier in Java

The public access modifier is the most permissive access level in Java. When a class, method, or variable is declared public, it can be accessed from anywhere within the program, across packages, subclasses, and external modules. This is useful when creating APIs, libraries, utility classes, or functions that need to be accessed globally. Public modifiers are often used for essential components like main methods, model classes, controllers, or entry-point functionalities in Java applications. It is important, however, to use public access carefully because excessive usage may expose internal implementation details. In well-designed programs, only the necessary methods are declared public while the internal logic is kept hidden. Below is an example demonstrating a public class and public method.

Example of Public Access Modifier

public class PublicDemo {
    public int number = 50;

    public void display() {
        System.out.println("Public Method: Number = " + number);
    }

    public static void main(String[] args) {
        PublicDemo obj = new PublicDemo();
        obj.display();
    }
}

Output:

Public Method: Number = 50

2. Private Access Modifier in Java

The private access modifier is the most restrictive modifier in Java. When a variable or method is declared private, it becomes accessible only within the same class. Private members cannot be accessed directly from other classes, subclasses, or even classes within the same package. Private modifiers help implement data hiding, which is one of the core principles of object-oriented programming. By making fields private, developers prevent unauthorized modification of data and ensure better control over how values are set or retrieved. Access to private members is usually provided using getter and setter methods. Constructors can also be private, commonly used in Singleton Design Patterns. Below is a clear example showing how private variables work.

Example of Private Access Modifier

class PrivateDemo {
    private String message = "Private Data";

    private void showMessage() {
        System.out.println("Message: " + message);
    }

    public void accessPrivate() {
        showMessage();
    }
}

public class TestPrivate {
    public static void main(String[] args) {
        PrivateDemo obj = new PrivateDemo();
        obj.accessPrivate();
    }
}

Output:

Message: Private Data

3. Default (Package-Private) Access Modifier

When no access modifier is specified, Java uses default access, also called package-private access. This means the class members are accessible only within the same package. Classes with default access cannot be accessed from outside the package. Default access is useful when classes or methods are meant to be shared internally within a module but should not be exposed to the entire application. It promotes modular development and acts as a boundary between packages. Default access is commonly used in frameworks and layered architectures where internal logic must remain hidden. Below is an example demonstrating how default access modifies behavior.

Example of Default Access Modifier

// File: PackageOne/DefaultDemo.java
package PackageOne;

class DefaultDemo {
    int value = 100;

    void showValue() {
        System.out.println("Default Value: " + value);
    }
}

// File: PackageOne/TestDefault.java
package PackageOne;

public class TestDefault {
    public static void main(String[] args) {
        DefaultDemo obj = new DefaultDemo();
        obj.showValue();
    }
}

Output:

Default Value: 100

4. Protected Access Modifier in Java

The protected access modifier allows access within the same package and also to subclasses even if they are in different packages. It is an essential modifier for inheritance-based applications. Protected access is useful when a parent class needs to expose specific functionalities only to its subclasses while keeping them hidden from other classes. Many real-world Java frameworks such as Spring, Hibernate, JDBC, and Swing use protected members to allow customization and extension through inheritance. Protected fields and methods facilitate reusability, controlled extension, and maintainable object-oriented design. The following example demonstrates protected access.

Example of Protected Access Modifier

// File: ParentPackage/ParentClass.java
package ParentPackage;

public class ParentClass {
    protected String data = "Protected Data";

    protected void displayData() {
        System.out.println("Inside Parent: " + data);
    }
}

// File: ChildPackage/ChildClass.java
package ChildPackage;

import ParentPackage.ParentClass;

public class ChildClass extends ParentClass {
    public void accessProtected() {
        displayData();
    }

    public static void main(String[] args) {
        ChildClass obj = new ChildClass();
        obj.accessProtected();
    }
}

Output:

Inside Parent: Protected Data

Access Levels Comparison Table

The following comparison helps developers understand how different access modifiers behave across class boundaries. This table is crucial for interview preparation, real-time projects, API development, and object-oriented design. It makes it easy to visualize the levels of access allowed in Java for classes and class members. Understanding this helps in writing secure, modular, object-oriented code.

Access Modifiers with Classes, Methods, and Variables

Access modifiers behave differently depending on whether they are applied to classes or members inside a class. Only public and default access can be used at the top-level class level. Private and protected cannot be applied to top-level classes. Methods and variables, however, support all four access modifiers. Developers use a combination of these modifiers to control how objects interact and how modules communicate. For example, fields are often private, methods commonly public, and constructors may be private or protected based on design patterns. This structured approach helps enforce encapsulation and ensures safe interaction between objects in large-scale applications.

Example: Access Modifiers in a Single Class

class AccessExample {
    public int a = 10;
    private int b = 20;
    protected int c = 30;
    int d = 40; // default

    public void showA() {
        System.out.println("Public A: " + a);
    }

    private void showB() {
        System.out.println("Private B: " + b);
    }

    protected void showC() {
        System.out.println("Protected C: " + c);
    }

    void showD() {
        System.out.println("Default D: " + d);
    }

    public static void main(String args[]) {
        AccessExample obj = new AccessExample();
        obj.showA();
        obj.showB();
        obj.showC();
        obj.showD();
    }
}

Output:

Public A: 10
Private B: 20
Protected C: 30
Default D: 40

Use Cases of Access Modifiers

Access modifiers are widely used across professional Java applications such as banking systems, enterprise software, APIs, backend applications, and Android development. Public modifiers are used for API endpoints, controllers, and service classes. Private modifiers are used for sensitive data such as account balance, passwords, configurations, and internal logic that should not be exposed to the outside world. Protected modifiers are widely used in frameworks where base classes provide functionality to child classes, allowing extension but preventing unrestricted access. Default access helps in logical grouping of classes within a package and supports modular application development. Overall, access modifiers are essential tools for maintaining security, performance, readability, modularity, and extensibility.

Java Access Modifiers form the backbone of secure and well-structured object-oriented programming in Java. They help developers control how classes interact, how data flows across modules, and how objects communicate in large-scale applications. Public, private, protected, and default access levels each serve unique purposes that contribute to encapsulation, inheritance, security, and maintainability. Mastering access modifiers is essential for writing professional, secure, and optimized Java programs. This detailed note provides all important concepts, examples, outputs, and explanations necessary for beginners, intermediate learners, and advanced Java developers.