What are access modifiers in Java?

Access modifiers in Java are keywords that set the accessibility (scope) of classes, constructors, methods, and data members (fields). They control the visibility of a member from other classes or packages. Properly using access modifiers is crucial for encapsulation and managing the visibility of components within a Java application.

Understanding Access Modifiers

Access modifiers help to restrict access to classes, methods, and variables from other parts of the code. This is a core concept of encapsulation in object-oriented programming, allowing developers to hide internal implementation details and expose only what is necessary.

Types of Access Modifiers

Java provides four types of access modifiers:

1. Public

The public access modifier specifies that the class, method, or data member is accessible from anywhere. There are no restrictions on its visibility.

public class MyClass {
    public int publicVar = 10;
    public void publicMethod() {
        System.out.println("This is a public method.");
    }
}

2. Protected

The protected access modifier specifies that the class, method, or data member is accessible within the same package and by subclasses (whether they are in the same package or a different package).

package com.example.pack1;

public class Parent {
    protected int protectedVar = 20;
    protected void protectedMethod() {
        System.out.println("This is a protected method.");
    }
}

// In a different package, a subclass can access protected members
package com.example.pack2;
import com.example.pack1.Parent;

public class Child extends Parent {
    public void accessProtected() {
        System.out.println(protectedVar); // Accessible
        protectedMethod();             // Accessible
    }
}

3. Default (Package-Private)

When no access modifier is specified for a class, method, or data member, it is considered default (or package-private). This means it is only accessible within the same package. It cannot be accessed from outside the package.

package com.example.pack1;

class DefaultClass {
    int defaultVar = 30; // default access
    void defaultMethod() { // default access
        System.out.println("This is a default method.");
    }
}

// In the same package, can access
public class AnotherClassInPack1 {
    public void useDefault() {
        DefaultClass obj = new DefaultClass();
        System.out.println(obj.defaultVar); // Accessible
        obj.defaultMethod();             // Accessible
    }
}

// In a different package, cannot access
// package com.example.pack2;
// import com.example.pack1.DefaultClass;
// public class SomeOtherClass {
//    public void tryAccess() {
//        DefaultClass obj = new DefaultClass(); // Compile-time error: DefaultClass is not public
//    }
// }

4. Private

The private access modifier specifies that the method or data member is only accessible within the class in which it is declared. It is the most restrictive modifier and promotes strong encapsulation.

public class MyPrivateClass {
    private int privateVar = 40;
    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    public void accessPrivate() {
        System.out.println(privateVar);   // Accessible within the same class
        privateMethod();               // Accessible within the same class
    }
}

Access Modifiers Summary Table

Best Practices

• Use private for fields to enforce encapsulation. Access them via public getter/setter methods.
• Use public for methods that define the public API of a class.
• Use protected when you want to allow subclasses to extend or modify behavior, but prevent direct access from unrelated classes.
• Use default (package-private) for helper classes or methods that are only relevant within a specific package, keeping them hidden from the rest of the application.

Choosing the right access modifier is critical for designing robust, maintainable, and secure Java applications. It directly impacts the object-oriented principles of encapsulation and modularity.