Access Modifiers in Java | Control Access Levels

Access modifiers in Java control the visibility and accessibility of classes, methods, and variables. They define how other classes can interact with a given class or its members, promoting encapsulation and modularity.

Types of Access Modifiers in Java:

• Public: The public modifier allows access from any other class. It is the most permissive level, where classes, methods, or variables marked as public are accessible from all packages.
• Protected: Members marked as protected are accessible within the same package and by subclasses, even if the subclass is in a different package.
• Default (Package-Private): If no access modifier is specified, the member is accessible only within the same package. This is sometimes called "package-private" access.
• Private: Members marked as private are accessible only within the class they are defined in, ensuring maximum encapsulation.

Comparison of Access Modifiers:

Example of Access Modifiers in Java:

This example demonstrates the use of different access modifiers in a Java class.

package com.example.access;
public class AccessExample {
    public int publicVariable = 1;
    protected int protectedVariable = 2;
    int defaultVariable = 3; // package-private
    private int privateVariable = 4;

    public void publicMethod() {
        System.out.println("Public Method");
    }

    protected void protectedMethod() {
        System.out.println("Protected Method");
    }

    void defaultMethod() {
        System.out.println("Default Method");
    }

    private void privateMethod() {
        System.out.println("Private Method");
    }
}

Using Access Modifiers:

This example shows access to the AccessExample class members from another class in the same package and a subclass in a different package.

Access within the Same Package

package com.example.access;
public class SamePackageAccess {
    public static void main(String[] args) {
        AccessExample example = new AccessExample();
        System.out.println(example.publicVariable); // Accessible
        System.out.println(example.protectedVariable); // Accessible
        System.out.println(example.defaultVariable); // Accessible
        // System.out.println(example.privateVariable); // Not accessible

        example.publicMethod(); // Accessible
        example.protectedMethod(); // Accessible
        example.defaultMethod(); // Accessible
        // example.privateMethod(); // Not accessible
    }
}

Access from a Subclass in a Different Package

package com.example.subclass;
import com.example.access.AccessExample;
public class SubclassAccess extends AccessExample {
    public static void main(String[] args) {
        SubclassAccess example = new SubclassAccess();
        System.out.println(example.publicVariable); // Accessible
        System.out.println(example.protectedVariable); // Accessible
        // System.out.println(example.defaultVariable); // Not accessible
        // System.out.println(example.privateVariable); // Not accessible

        example.publicMethod(); // Accessible
        example.protectedMethod(); // Accessible
        // example.defaultMethod(); // Not accessible
        // example.privateMethod(); // Not accessible
    }
}

Detailed Explanation:

• Encapsulation: Access modifiers help encapsulate data by restricting access to the internal state of classes.
• Visibility: Using access modifiers effectively controls the visibility of class members across different packages.
• Inheritance: Protected access facilitates controlled inheritance, allowing subclasses access without exposing members to the broader package.
• Modularity: By controlling access levels, classes remain modular and independent, encouraging clear boundaries and better code organization.

Access modifiers are essential in Java to create robust, secure, and modular programs with well-defined visibility and access control.