Access Modifiers in Java: Types, Uses & Examples Explained

Access Modifiers in Java: A Complete Guide

Access modifiers in Java are essential for controlling the visibility and accessibility of classes, methods, variables, and constructors. They are used to provide security, manage access, and define the scope of elements within your code. In this blog, we will explore the four types of access modifiers available in Java, their uses, and some key examples to understand how they work. Additionally, we will provide a basic algorithm to implement access modifiers effectively and address common questions related to this topic.

Types of Access Modifiers in Java

Java provides four main types of access modifiers:

1. Default (Package-Private)
2. Private
3. Protected
4. Public

Each modifier has a specific role in determining the visibility of a class, method, or variable across different parts of your program. Let's dive into each one.

1. Default Access Modifier (No Keyword Required)

When you do not explicitly specify an access modifier for a class, method, or data member, it defaults to the package-private (default) access level. Elements with the default access modifier are accessible only within the same package. This restricts their scope, making them invisible to other packages.

Example:

// Java program to illustrate default modifier
package p1;

// Class Geek has default access modifier
class Geek {
    void display() {
        System.out.println("Hello World!");
    }
}

Usage in Another Package (p2) – Error

package p2;
import p1.*;

class GeekNew {
    public static void main(String[] args) {
        Geek obj = new Geek(); // Compile-time error
        obj.display();
    }
}

2. Private Access Modifier

The private access modifier is the most restrictive. Methods or data members declared as private are accessible only within the class where they are declared. It ensures that the data cannot be altered or accessed directly from outside the class.

Example:

package p1;

class A {
    private void display() {
        System.out.println("GeeksforGeeks");
    }
}

class B {
    public static void main(String[] args) {
        A obj = new A();
        obj.display(); // Compile-time error: 'display()' has private access in 'A'
    }
}

3. Protected Access Modifier

The protected access modifier allows the elements to be accessible within the same package and by subclasses in other packages. It provides a middle-ground between private and public, offering both security and inheritance capabilities.

Example:

Program 1:

package p1;

public class A {
    protected void display() {
        System.out.println("GeeksforGeeks");
    }
}

Program 2:

package p2;
import p1.*;

class B extends A {
    public static void main(String[] args) {
        B obj = new B();
        obj.display(); // Output: GeeksforGeeks
    }
}

4. Public Access Modifier

The public access modifier has the widest scope. Classes, methods, or data members declared as public are accessible from anywhere in the program, including different packages.

Example:

Program 1:

package p1;

public class A {
    public void display() {
        System.out.println("GeeksforGeeks");
    }
}

Program 2:

package p2;
import p1.*;

class B {
    public static void main(String[] args) {
        A obj = new A();
        obj.display(); // Output: GeeksforGeeks
    }
}

Key Points to Remember

1. Use private for members that should only be accessible within the same class.
2. Use protected for members that should be available to subclasses but not to the general public.
3. Use public for members that should be accessible from anywhere in the program.
4. Avoid using public fields unless they are constants. Utilize getter and setter methods to manage access.

Algorithm for Using Access Modifiers in Java

1. Define the Class: Create a class that represents the object you want to manage.
2. Set Instance Variables: Define the data members for the class.
3. Choose the Access Modifier:

• Private: Use for variables that should be accessed only within the class.
• Protected: Use for variables that should be accessed within the class and its subclasses.
• Public: Use for variables that should be accessible from anywhere.

1. Encapsulation: Use getter and setter methods for managing access to variables.

FAQs on Access Modifiers in Java

1. What are access modifiers in Java? Access modifiers are keywords in Java that determine the visibility and accessibility of classes, fields, methods, and constructors within different parts of a program.

2. What is the most restrictive access modifier? The private modifier is the most restrictive, allowing access only within the same class.

3. What are the 12 modifiers in Java? The 12 modifiers in Java include: public, private, protected, default, static, final, synchronized, abstract, native, strictfp, transient, and volatile.

4. Can a top-level class be private or protected? No, top-level classes cannot be declared as private or protected. Only nested (inner) classes can use these modifiers.

5. How do default and protected modifiers differ? Default access allows visibility within the same package only, while protected extends the visibility to subclasses even if they are in different packages.

Conclusion

Access modifiers are a vital part of Java programming, providing control over the visibility and scope of code elements. Using them effectively can improve code security, structure, and readability. Always aim to use the most restrictive access modifier that suits your need, and leverage encapsulation by using getters and setters.

Learn More: javascript window.location.reload()