Access Modifiers

Introduction

Access modifiers in Java are keywords that control the visibility of classes, attributes, methods, and constructors. They determine which parts of a program can access a particular class member.

Java provides four access levels:

public :- Accessible everywhere (within the same class, same package, and outside the package).
private :- Accessible only within the class where it is declared.
protected :- Accessible within the same package and by subclasses in other packages.
Default (No modifier) :- Accessible within the same package (package-private).

Why Are Access Modifiers Used?

Access modifiers help developers:

Protect important data from direct access
Implement encapsulation
Control how classes and members are used
Prevent unwanted modifications
Make programs easier to maintain

Types of Access Modifiers in Java

1. Public

The public access modifier can make the attributes and methods of a class accessible from anywhere in the program, including classes outside the package. For example, consider the following code snippet:

1import java.util.*;
2
3class Employee {
4    public String name; // Public attribute
5
6    public void displayName() { // Public method
7        System.out.println("Employee Name: " + name);
8    }
9}
10
11class Main {
12    public static void main(String[] args) {
13        Employee emp = new Employee();
14        emp.name = "Alice"; // Accessible globally
15        emp.displayName();  // Accessible globally
16    }
17}

Here, the name attribute and the displayName() method are set to public so they can be accessed from outside the class (in the main method).

Public

2. Private

The private access modifier can make the attributes and methods of a class accessible only within the class where they were declared. For example, consider the following code snippet:

1import java.util.*;
2
3class BankAccount {
4    private double balance; // Private attribute
5
6    // Getter to provide controlled access
7    public double getBalance() {
8        return balance;
9    }
10
11    // Public method to deposit money
12    public void deposit(double amount) {
13        if (amount > 0) {
14            balance += amount;
15        }
16    }
17}
18
19// Main Class
20class Main {
21    public static void main(String[] args) {
22        // Creating an object
23        BankAccount acnt = new BankAccount();
24        
25        System.out.println(acnt.balance); // Throws an error
26        System.out.println(acnt.getBalance());
27    }
28}

Here, the balance attribute is set to private, so it can only be accessed from within the class (using the getBalance() method) and throws an error when accessed outside of the class.

Private

3. Protected

The protected access modifier can make the attributes and methods of a class accessible within the same package and in subclasses (even if they are in different packages). For example, consider the following code snippet:

1import java.util.*;
2
3class Vehicle {
4    protected String type; // Protected attribute
5
6    protected void displayType() { // Protected method
7        System.out.println("Vehicle Type: " + type);
8    }
9}
10
11class Car extends Vehicle {
12    public Car() {
13        this.type = "Car"; // Accessible in the subclass
14    }
15}

Here, the subclasses can inherit and use the type attribute and displayType() method.

Protected

4. Default (No modifier)

When there is no access modifier specified, by default, the member is package-private in Java. This means that the member is accessible only in the package in which the class is declared, and nowhere else.

Consider the following code snippet:

1import java.util.*;
2
3class PackageDemo {
4    void showMessage() { // Default access
5        System.out.println("Default access in the same package.");
6    }
7}
8
9public class Main {
10    public static void main(String[] args) {
11        PackageDemo demo = new PackageDemo();
12        demo.showMessage(); // Accessible because it's in the same package
13    }
14}

Default

Java Access Modifiers Table

Modifier	Same Class	Same Package	Subclass Outside Package	Everywhere
`public`	Yes	Yes	Yes	Yes
`protected`	Yes	Yes	Yes	No
`Default (No modifier)`	Yes	Yes	No	No
`private`	Yes	No	No	No

Summary

Access modifiers in Java are keywords that control the visibility and accessibility of classes and their members. Java provides four levels: public, private, protected, and default (package-private), each allowing access in different scopes.

They help protect data, implement encapsulation, and control how classes and members are used. public provides the widest access, while private provides the most restricted access, with protected and default offering intermediate levels.

Introduction

Why Are Access Modifiers Used?

Types of Access Modifiers in Java

1. Public

2. Private

3. Protected

4. Default (No modifier)

Java Access Modifiers Table

Summary

Read Similar Blogs

OS Protection and Security

How Many Apps Can Run Together

OS As A Resource Manager