Access Modifiers in OOP

What are Access Modifiers?

Access modifiers in Java are keywords that specify the accessibility or scope of a class, method, or variable. They control where these members can be accessed from. Java provides four types of access modifiers: public, protected, default (no modifier), and private.

Access Modifiers Kya Hain? (Hinglish)

Java mein access modifiers wo keywords hain jo class, method, ya variable ki accessibility ya scope ko specify karte hain. Ye control karte hain ki in members ko kahan se access kiya ja sakta hai. Java char types ke access modifiers provide karta hai: public, protected, default (no modifier), aur private.

Types of Access Modifiers

Modifier	Class	Package	Subclass	World
public	Yes	Yes	Yes	Yes
protected	Yes	Yes	Yes	No
default	Yes	Yes	No	No
private	Yes	No	No	No

Example Program

// Public class accessible from anywhere
public class Student {
    // Private variable accessible only within this class
    private String name;
    
    // Protected variable accessible in this class and subclasses
    protected int rollNumber;
    
    // Default variable accessible in this package
    String department;
    
    // Public variable accessible from anywhere
    public String university;
    
    // Private constructor
    private Student() {
        // Can only be called from within this class
    }
    
    // Public constructor
    public Student(String name, int rollNumber) {
        this.name = name;
        this.rollNumber = rollNumber;
    }
    
    // Protected method accessible in this class and subclasses
    protected void displayRollNumber() {
        System.out.println("Roll Number: " + rollNumber);
    }
    
    // Public method accessible from anywhere
    public void displayInfo() {
        System.out.println("Name: " + name);
        displayRollNumber();
    }
    
    // Default method accessible in this package
    void setDepartment(String department) {
        this.department = department;
    }
}

// Subclass in the same package
class CollegeStudent extends Student {
    public CollegeStudent(String name, int rollNumber) {
        super(name, rollNumber);
    }
    
    public void showDetails() {
        // Can access protected and public members
        displayRollNumber();
        displayInfo();
        
        // Can access default members in same package
        setDepartment("Computer Science");
        
        // Cannot access private members
        // System.out.println(name); // Error
    }
}

// Class in a different package
package anotherpackage;

import Student;

public class University {
    public void processStudent(Student student) {
        // Can access only public members
        student.displayInfo();
        student.university = "ABC University";
        
        // Cannot access protected, default, or private members
        // student.displayRollNumber(); // Error
        // student.setDepartment("Math"); // Error
        // student.name = "John"; // Error
    }
}

Program Explanation (Hinglish)

Is program mein humne different access modifiers ka use kiya hai:

Private Members: name variable aur private constructor jo sirf class ke andar access ho sakte hain
Protected Members: rollNumber variable aur displayRollNumber() method jo class aur subclasses mein access ho sakte hain
Default Members: department variable aur setDepartment() method jo same package mein access ho sakte hain
Public Members: university variable aur displayInfo() method jo kahi se bhi access ho sakte hain

Important Points

Public members are accessible from anywhere
Protected members are accessible in the same package and subclasses
Default members are accessible only in the same package
Private members are accessible only within the same class
Access modifiers help in encapsulation and data hiding