// Java Access Modifiers

Access Modifiers
Complete Guide

Basic se Advanced tak — har concept clearly samjhao with VS Code–style code examples. Minimum 3–5 programs per topic.

01

Introduction

Access Modifiers control karte hain ki koi class, method, ya variable kahan se accessible hai. Java mein 4 types hain.

1 What Are Access Modifiers?
Concept: Ek simple class mein saare 4 modifiers ko ek saath dekhna.
1// File: AccessDemo.java
2public class AccessDemo {
3 public int publicVar = 1; // sabko access
4 protected int protectedVar = 2; // subclass + same pkg
5 int defaultVar = 3; // same package only
6 private int privateVar = 4; // sirf is class
7
8 public static void main(String[] args) {
9 AccessDemo obj = new AccessDemo();
10 System.out.println("Public: " + obj.publicVar);
11 System.out.println("Protected: " + obj.protectedVar);
12 System.out.println("Default: " + obj.defaultVar);
13 System.out.println("Private: " + obj.privateVar);
14 }
15}
// Output Public: 1 Protected: 2 Default: 3 Private: 4
2 Visibility Levels Demo
Concept: Package alag hone par kya access milta hai.
1// package: com.demo
2package com.demo;
3public class Bank {
4 public String bankName = "SBI";
5 protected double rate = 6.5;
6 String branch = "Indore";
7 private String password = "secret";
8}
9
10// Different package: com.other
11package com.other;
12import com.demo.Bank;
13public class Customer {
14 public static void main(String[] args) {
15 Bank b = new Bank();
16 System.out.println(b.bankName); // ✅ OK
17 // b.rate → ❌ protected - no inheritance
18 // b.branch → ❌ default - diff package
19 // b.password → ❌ private
20 }
21}
// Output SBI
02

Access Modifier – Quick Reference Table

Kahan se accessible hai — ek nazar mein samjho.

Modifier Same Class Same Package Subclass (Diff Pkg) Other Package
public ✔ ✔ ✔ ✔
protected ✔ ✔ ✔ ✘
default ✔ ✔ ✘ ✘
private ✔ ✘ ✘ ✘
📌 Yaad Rakho Visibility order: private < default < protected < public. Jitna restricted, utna secure. Encapsulation ke liye hamesha minimum access do.
public

public Modifier

Sabse open access — koi bhi class, koi bhi package se access kar sakta hai.

1 Public Class & Method
Concept: Public class aur public methods — sabse simple example.
1public class Greet {
2 public String name;
3
4 public Greet(String name) {
5 this.name = name;
6 }
7
8 public void sayHello() {
9 System.out.println("Hello, " + name + "!");
10 }
11
12 public static void main(String[] args) {
13 Greet g = new Greet("Rahul");
14 g.sayHello();
15 System.out.println("Name: " + g.name);
16 }
17}
// Output Hello, Rahul! Name: Rahul
2 Public Across Packages
Concept: Alag package se public member ko access karna.
1// Package: animals
2package animals;
3public class Animal {
4 public String sound = "Generic sound";
5 public void makeSound() {
6 System.out.println("Sound: " + sound);
7 }
8}
9
10// Package: zoo
11package zoo;
12import animals.Animal;
13public class ZooMain {
14 public static void main(String[] args) {
15 Animal a = new Animal();
16 a.sound = "Roar"; // ✅ public field
17 a.makeSound(); // ✅ public method
18 }
19}
// Output Sound: Roar
3 Public Static Methods (Utility)
Concept: Public static — object banaye bina directly call karo (Math class jaisa).
1public class MathUtil {
2 public static int square(int n) {
3 return n * n;
4 }
5 public static double circleArea(double r) {
6 return Math.PI * r * r;
7 }
8 public static void main(String[] args) {
9 System.out.println(MathUtil.square(5));
10 System.out.printf("%.2f%n", MathUtil.circleArea(3));
11 }
12}
// Output 25 28.27
4 Public Interface
Concept: Interface ke saath public modifier ka use — contract define karna.
1public interface Printable {
2 public void print(); // implicitly public
3}
4public class Document implements Printable {
5 private String content;
6 public Document(String c) { this.content = c; }
7 @Override
8 public void print() {
9 System.out.println("Printing: " + content);
10 }
11 public static void main(String[] args) {
12 Printable doc = new Document("Java Notes");
13 doc.print();
14 }
15}
// Output Printing: Java Notes
protected

protected Modifier

Same package + subclass (even different package) se accessible. Inheritance ke liye perfect.

1 Protected in Inheritance
Concept: Parent class ka protected member child class access kar sakti hai.
1class Vehicle {
2 protected String brand = "Honda";
3 protected void start() {
4 System.out.println(brand + " engine started.");
5 }
6}
7class Car extends Vehicle {
8 void display() {
9 System.out.println("Brand: " + brand);// ✅
10 start(); // ✅ inherited
11 }
12 public static void main(String[] args) {
13 new Car().display();
14 }
15}
// Output Brand: Honda Honda engine started.
2 Protected Method Override
Concept: Child class protected method ko override kar sakta hai (visibility badhana allowed).
1class Shape {
2 protected double area() {
3 return 0.0;
4 }
5}
6class Circle extends Shape {
7 private double radius;
8 Circle(double r) { this.radius = r; }
9 @Override
10 public double area() { // ✅ wider access ok
11 return Math.PI * radius * radius;
12 }
13 public static void main(String[] args) {
14 Shape s = new Circle(5);
15 System.out.printf("Area = %.2f%n", s.area());
16 }
17}
// Output Area = 78.54
3 Protected Constructor
Concept: Protected constructor — sirf subclass ya same package se object bana sakte hain.
1class Database {
2 private static Database instance;
3 protected Database() {
4 System.out.println("DB Connected");
5 }
6 public static Database getInstance() {
7 if (instance == null)
8 instance = new Database();
9 return instance;
10 }
11 public static void main(String[] args) {
12 Database d1 = Database.getInstance();
13 Database d2 = Database.getInstance();
14 System.out.println(d1 == d2); // true (Singleton)
15 }
16}
// Output DB Connected true
4 Protected with super Keyword
Concept: Child class super keyword se parent ka protected method call kare.
1class Employee {
2 protected String name;
3 protected void showInfo() {
4 System.out.println("Emp: " + name);
5 }
6}
7class Manager extends Employee {
8 private String dept;
9 Manager(String n, String d) { name=n; dept=d; }
10 @Override
11 public void showInfo() {
12 super.showInfo(); // parent call
13 System.out.println("Dept: " + dept);
14 }
15 public static void main(String[] args) {
16 new Manager("Amit", "IT").showInfo();
17 }
18}
// Output Emp: Amit Dept: IT
default

default (Package-Private) Modifier

Koi keyword nahi likhte — automatic package-level access. Same package mein sab accessible, bahar kuch bhi nahi.

1 Default Access Demo
Concept: Same package mein default members accessible hain, alag package mein nahi.
1// Package: college
2package college;
3class Student { // default class
4 String name; // default field
5 int rollNo; // default field
6 void display() { // default method
7 System.out.println(rollNo+": "+name);
8 }
9}
10class CollegeMain { // same package ✅
11 public static void main(String[] args) {
12 Student s = new Student();
13 s.name = "Priya";
14 s.rollNo = 101;
15 s.display();
16 }
17}
// Output 101: Priya
2 Default vs Public Comparison
Concept: Ek class mein public aur default methods — difference clearly dikhana.
1package shop;
2public class Product {
3 public String name = "Phone";
4 double cost = 999.0; // default
5 public void showName() {
6 System.out.println("Product: "+name);
7 }
8 void showCost() { // default method
9 System.out.println("Cost: $"+cost);
10 }
11}
12// same package: both accessible
13class ShopTest {
14 public static void main(String[] args) {
15 Product p = new Product();
16 p.showName(); // ✅ public
17 p.showCost(); // ✅ same package
18 }
19}
// Output Product: Phone Cost: $999.0
3 Multiple Classes Same Package
Concept: Ek hi file mein do classes — default access freely shared.
1class Calculator {
2 int add(int a, int b) { return a+b; }
3 int mul(int a, int b) { return a*b; }
4}
5public class TestCalc {
6 public static void main(String[] args) {
7 Calculator c = new Calculator();
8 System.out.println("Add: " + c.add(10,5));
9 System.out.println("Mul: " + c.mul(10,5));
10 }
11}
// Output Add: 15 Mul: 50
private

private Modifier

Sabse restricted — sirf us class ke andar accessible. Encapsulation ka backbone.

1 Private + Getter/Setter
Concept: Private fields ko public getters/setters se access karo — proper encapsulation.
1public class Person {
2 private String name;
3 private int age;
4
5 public String getName() { return name; }
6 public void setName(String n) { name = n; }
7 public int getAge() { return age; }
8 public void setAge(int a) {
9 if (a > 0) age = a; // validation
10 }
11 public static void main(String[] args) {
12 Person p = new Person();
13 p.setName("Neha");
14 p.setAge(25);
15 System.out.println(p.getName()+" - Age: "+p.getAge());
16 }
17}
// Output Neha - Age: 25
2 Private Methods
Concept: Private methods sirf class ke andar kaam karte hain — helper methods.
1public class ATM {
2 private double balance = 5000;
3
4 private boolean hasFunds(double amt) {
5 return balance >= amt;
6 }
7 public void withdraw(double amt) {
8 if (hasFunds(amt)) {
9 balance -= amt;
10 System.out.println("✅ Withdrawn: ₹"+amt);
11 System.out.println("Balance: ₹"+balance);
12 } else {
13 System.out.println("❌ Insufficient!");
14 }
15 }
16 public static void main(String[] args) {
17 ATM atm = new ATM();
18 atm.withdraw(2000);
19 atm.withdraw(4000);
20 }
21}
// Output ✅ Withdrawn: ₹2000.0 Balance: ₹3000.0 ❌ Insufficient!
3 Private with Immutable Class
Concept: Private final fields — object create hone ke baad change nahi hota (immutable).
1public final class ImmutablePoint {
2 private final int x;
3 private final int y;
4 public ImmutablePoint(int x, int y) {
5 this.x = x; this.y = y;
6 }
7 public int getX() { return x; }
8 public int getY() { return y; }
9 public String toString() {
10 return "("+x+", "+y+")";
11 }
12 public static void main(String[] args) {
13 ImmutablePoint p = new ImmutablePoint(3, 7);
14 System.out.println("Point: " + p);
15 // p.x = 10; ❌ Cannot reassign final
16 }
17}
// Output Point: (3, 7)
4 Private with Validation
Concept: Setter mein private field set karne se pehle validate karo — data integrity.
1public class BankAccount {
2 private double balance;
3 private String owner;
4 public BankAccount(String o, double b) {
5 owner = o;
6 balance = (b >= 0) ? b : 0;
7 }
8 public void deposit(double amt) {
9 if(amt > 0) balance += amt;
10 }
11 public double getBalance() { return balance; }
12 public static void main(String[] args) {
13 BankAccount acc =
14 new BankAccount("Arjun", 1000);
15 acc.deposit(500);
16 System.out.println("₹"+acc.getBalance());
17 }
18}
// Output ₹1500.0
Class

Class-Level Modifiers

Top-level class ke liye sirf public ya default allowed hai. abstract, final, static (nested) bhi dekhte hain.

1 public class vs default class
Concept: Public class — bahar se import ho sakti hai. Default class — sirf same package.
1// File: PublicDemo.java
2public class PublicDemo { // ✅ accessible everywhere
3 public static void main(String[] args) {
4 Helper h = new Helper();
5 h.greet();
6 }
7}
8class Helper { // default: same pkg only
9 void greet() {
10 System.out.println("I'm a helper class!");
11 }
12}
// Output I'm a helper class!
2 abstract class
Concept: Abstract class — directly instantiate nahi ho sakti, subclass banani padti hai.
1public abstract class Appliance {
2 protected String brand;
3 public abstract void turnOn();
4 public void showBrand() {
5 System.out.println("Brand: "+brand);
6 }
7}
8public class Fan extends Appliance {
9 Fan(String b) { brand = b; }
10 @Override
11 public void turnOn() {
12 System.out.println(brand+" fan is running 🌀");
13 }
14 public static void main(String[] args) {
15 Appliance a = new Fan("Usha");
16 a.showBrand(); a.turnOn();
17 }
18}
// Output Brand: Usha Usha fan is running 🌀
3 final class
Concept: Final class ko extend nahi kiya ja sakta — jaise Java ka String class.
1public final class Constants {
2 public static final double PI = 3.14159;
3 public static final int MAX = 100;
4 private Constants() {} // no instantiation
5}
6// class Child extends Constants {} ❌
7public class TestFinal {
8 public static void main(String[] args) {
9 System.out.println("PI = " + Constants.PI);
10 System.out.println("MAX = " + Constants.MAX);
11 }
12}
// Output PI = 3.14159 MAX = 100
4 Static Nested Class
Concept: Static nested class — outer class object bina bhi instantiate ho sakti hai.
1public class Outer {
2 private static int count = 0;
3
4 public static class Inner {
5 public void show() {
6 count++; // can access static
7 System.out.println("Count = "+count);
8 }
9 }
10 public static void main(String[] args) {
11 Outer.Inner i = new Outer.Inner();
12 i.show(); i.show();
13 }
14}
// Output Count = 1 Count = 2
Constructor

Constructor Access Modifiers

Constructor par bhi access modifier lagta hai — yeh control karta hai ki kahan se object ban sakta hai.

1 public Constructor
Concept: Public constructor — kahin se bhi object bana sakte hain.
1public class Book {
2 private String title;
3 private String author;
4
5 public Book(String t, String a) {
6 title = t; author = a;
7 }
8 public void info() {
9 System.out.println("\""+title+"\" by "+author);
10 }
11 public static void main(String[] args) {
12 Book b1 = new Book("Java OOPS", "Jeetu");
13 Book b2 = new Book("Design Patterns", "GoF");
14 b1.info(); b2.info();
15 }
16}
// Output "Java OOPS" by Jeetu "Design Patterns" by GoF
2 private Constructor (Singleton)
Concept: Private constructor se Singleton pattern — ek hi object kabhi bhi.
1public class AppConfig {
2 private static AppConfig instance;
3 private String theme = "dark";
4
5 private AppConfig() {} // private ctor
6
7 public static AppConfig get() {
8 if (instance == null)
9 instance = new AppConfig();
10 return instance;
11 }
12 public String getTheme() { return theme; }
13 public static void main(String[] args) {
14 AppConfig c1 = AppConfig.get();
15 AppConfig c2 = AppConfig.get();
16 System.out.println(c1.getTheme());
17 System.out.println("Same? "+(c1==c2));
18 }
19}
// Output dark Same? true
3 Constructor Overloading with Modifiers
Concept: Multiple constructors — alag-alag access modifiers ke saath.
1public class Rectangle {
2 private double width, height;
3
4 public Rectangle() { // default square
5 width = height = 1;
6 }
7 public Rectangle(double s) { // square
8 width = height = s;
9 }
10 public Rectangle(double w, double h) {
11 width = w; height = h;
12 }
13 public double area() { return width*height; }
14 public static void main(String[] args) {
15 System.out.println(new Rectangle().area());
16 System.out.println(new Rectangle(4).area());
17 System.out.println(new Rectangle(3,5).area());
18 }
19}
// Output 1.0 16.0 15.0
4 protected Constructor (Factory)
Concept: Protected constructor — Factory Method Pattern ke liye useful.
1abstract class Logger {
2 protected Logger() {}
3 public abstract void log(String msg);
4}
5class ConsoleLogger extends Logger {
6 public ConsoleLogger() { super(); }
7 @Override
8 public void log(String msg) {
9 System.out.println("[LOG] "+msg);
10 }
11}
12public class TestLogger {
13 public static void main(String[] args) {
14 Logger l = new ConsoleLogger();
15 l.log("App Started");
16 l.log("User logged in");
17 }
18}
// Output [LOG] App Started [LOG] User logged in
Advanced

Advanced Concepts

Real-world patterns — encapsulation, inheritance combinations, inner classes, interface aur lambda ke saath modifiers.

1 Encapsulation (Real-world)
Concept: Complete encapsulation example — Student grade system with validation.
1public class StudentGrade {
2 private String name;
3 private int marks;
4
5 public StudentGrade(String n, int m) {
6 name = n;
7 setMarks(m);
8 }
9 public void setMarks(int m) {
10 marks = (m>=0&&m<=100) ? m : 0;
11 }
12 private String calcGrade() {
13 if(marks>=90) return "A+";
14 if(marks>=75) return "A";
15 if(marks>=60) return "B";
16 return "C";
17 }
18 public void report() {
19 System.out.printf(
20 "%s → %d marks → Grade: %s%n",
21 name, marks, calcGrade());
22 }
23 public static void main(String[] args) {
24 new StudentGrade("Riya",92).report();
25 new StudentGrade("Rohan",67).report();
26 }
27}
// Output Riya → 92 marks → Grade: A+ Rohan → 67 marks → Grade: B
2 Inner Class Access
Concept: Non-static inner class outer class ke private members access kar sakti hai.
1public class Computer {
2 private String model = "Dell XPS";
3
4 public class Processor { // inner
5 private String cpu = "i9";
6 public void specs() {
7 // ✅ can access outer private
8 System.out.println(model+" - "+cpu);
9 }
10 }
11 public static void main(String[] args) {
12 Computer c = new Computer();
13 Computer.Processor p =
14 c.new Processor();
15 p.specs();
16 }
17}
// Output Dell XPS - i9
3 Builder Pattern with private Constructor
Concept: Builder pattern — complex object step-by-step banao, private main constructor.
1public class Pizza {
2 private final String size;
3 private final boolean cheese, pepperoni;
4
5 private Pizza(Builder b) {
6 size=b.size; cheese=b.cheese; pepperoni=b.pepperoni;
7 }
8 public static class Builder {
9 private String size;
10 private boolean cheese, pepperoni;
11 public Builder size(String s) { size=s; return this; }
12 public Builder cheese() { cheese=true; return this; }
13 public Builder pepperoni() { pepperoni=true; return this; }
14 public Pizza build() { return new Pizza(this); }
15 }
16 public String toString() {
17 return size+" Pizza | cheese:"+cheese+" | pepperoni:"+pepperoni;
18 }
19 public static void main(String[] args) {
20 Pizza p = new Pizza.Builder()
21 .size("Large").cheese().pepperoni().build();
22 System.out.println(p);
23 }
24}
// Output Large Pizza | cheese:true | pepperoni:true
4 Interface + Lambda + Access
Concept: Functional interface ke methods always public hote hain — lambda se implement karo.
1@FunctionalInterface
2public interface Transformer {
3 String transform(String s); // public by default
4}
5public class TextProcessor {
6 public static String process(
7 String text, Transformer t) {
8 return t.transform(text);
9 }
10 public static void main(String[] args) {
11 System.out.println(
12 process("hello", s -> s.toUpperCase()));
13 System.out.println(
14 process(" Java ", String::trim));
15 }
16}
// Output HELLO Java
5 All Modifiers Together (Real Project)
Concept: Library Management System — saare 4 modifiers ek realistic scenario mein.
1public class Library {
2 public String libraryName = "City Library";
3 protected int totalBooks = 500;
4 String city = "Indore";
5 private String adminPass = "lib@2024";
6
7 public void showName() {
8 System.out.println("📚 "+libraryName);
9 }
10 protected void showBooks() {
11 System.out.println("Books: "+totalBooks);
12 }
13 private boolean auth(String p) {
14 return adminPass.equals(p);
15 }
16 public void adminLogin(String p) {
17 System.out.println(auth(p) ? "✅ Login OK" : "❌ Denied");
18 }
19 public static void main(String[] args) {
20 Library lib = new Library();
21 lib.showName();
22 lib.showBooks();
23 lib.adminLogin("lib@2024");
24 lib.adminLogin("wrong");
25 }
26}
// Output 📚 City Library Books: 500 ✅ Login OK ❌ Denied
Interview

Interview Questions & Answers

Top interview questions jo Java access modifiers pe pooche jaate hain — clear aur concise answers ke saath.

Java mein kitne access modifiers hain? Name karo.
Java mein 4 access modifiers hain: public (sabko access), protected (same pkg + subclass), default (no keyword, same pkg only), aur private (sirf us class mein). Visibility order: private < default < protected < public.
private aur default mein kya fark hai?
private — sirf us class ke andar accessible. default — same package ke andar kisi bhi class se accessible. Dono alag package se accessible nahi hote, lekin default same-package classes mein freely use ho sakta hai jabki private sirf apni class tak simit hai.
Kya top-level class ko private bana sakte hain?
Nahi. Top-level class sirf public ya default ho sakti hai. private aur protected sirf nested classes, methods, aur fields ke liye use hote hain. Private top-level class ka koi matlab nahi kyunki koi use access hi nahi kar sakta.
protected vs default mein kya difference hai?
default — sirf same package mein kaam karta hai, inheritance se koi fark nahi. protected — same package PLUS alag package ki subclass mein bhi accessible hai. Agar class B extends A hai aur A protected hai, to B alag package mein bhi A ke protected members access kar sakti hai.
Override karte waqt access modifier ko narrow kar sakte hain?
Nahi. Override mein visibility badha sakte hain, ghata nahi sakte. Agar parent method protected hai, to child ushe public bana sakta hai — lekin private ya default nahi. Ye Liskov Substitution Principle ke against hoga.
Encapsulation kaise implement karte hain Java mein?
Fields ko private banao, aur unhe public getter/setter methods se access karo. Isse data hiding milti hai aur setters mein validation add kar sakte hain. Ye Java mein encapsulation ka standard pattern hai.
private constructor use karne ka kya reason hai?
private constructor se class ko directly instantiate hone se rokta hai. Use cases: (1) Singleton Pattern — sirf ek instance chahiye, (2) Utility classes jaise Math — sirf static methods hain, (3) Builder/Factory Pattern — creation logic control karna. new MyClass() compile error dega bahar se.
Interface ke methods ka default access modifier kya hota hai?
Interface ke saare methods implicitly public abstract hote hain (unless default ya static keyword use ho, Java 8+). Isliye interface implement karte waqt methods ko public hi likhna padta hai — tighter access allowed nahi.
Static nested class aur inner class mein kya fark hai access ke liye?
Static nested class — outer class ke sirf static members access kar sakti hai. Object banana: new Outer.Inner(). Non-static inner class — outer class ke saare members (private bhi) directly access kar sakti hai, lekin outer object zaruri hai: outerObj.new Inner().
Kya hoga agar same package mein do classes hain aur ek mein default method hai — dusri class access kar sakti hai?
Haan, kar sakti hai. Default (package-private) access same package ke andar freely accessible hai. Sirf alag package mein problem hoti hai. Same package ki dono classes — chahe alag files mein hon — default members freely share karti hain.
💡 Golden Rule for Interviews Hamesha minimum required access do — "Principle of Least Privilege". Private prefer karo jab tak bahar expose karna zaruri na ho. Ye clean OOP design ka sign hai.