Introduction

Imagine you're in a house with different rooms. Some rooms are open to everyone (public), some are only for family members (protected), some are just for you (private), and some follow the neighborhood rules (package-private). Access modifiers in Java work exactly like this - they control who can access your classes, methods, and variables!

Access modifiers are keywords that set the accessibility (visibility) of classes, methods, constructors, and fields. They're fundamental to encapsulation - one of the core principles of object-oriented programming.

---

What are Access Modifiers?

Access modifiers determine the scope and visibility of Java elements. They help you implement encapsulation by hiding internal implementation details and exposing only what's necessary.

The Four Access Levels:

Modifier	Class	Package	Subclass	World
private	✅	❌	❌	❌
default (no modifier)	✅	✅	❌	❌
protected	✅	✅	✅	❌
public	✅	✅	✅	✅

---

Code Explanation with Examples

Example 1: Comprehensive Access Modifier Demonstration

// File: Animal.java
public class Animal {
// 🎯 PUBLIC: Accessible from anywhere
public String publicName;
public void publicMethod() {
System.out.println("Public method - anyone can call me!");
}
// 🎯 PROTECTED: Accessible in package + subclasses (even in different packages)
protected String protectedSpecies;
protected void protectedMethod() {
System.out.println("Protected method - package and subclasses only");
}
// 🎯 DEFAULT (PACKAGE-PRIVATE): No modifier - accessible only in same package
String defaultHabitat; // No modifier = default access
void defaultMethod() {
System.out.println("Default method - same package only");
}
// 🎯 PRIVATE: Accessible only within the same class
private String privateSecret;
private void privateMethod() {
System.out.println("Private method - only I can call myself!");
}
// Constructor
public Animal(String name, String species, String habitat) {
this.publicName = name;
this.protectedSpecies = species;
this.defaultHabitat = habitat;
this.privateSecret = "Classified information";
}
// 🎯 Public method that uses private members (ENCAPSULATION)
public String getPublicInfo() {
return publicName + " is a " + protectedSpecies + " living in " + defaultHabitat;
}
// 🎯 Protected method that can access private members
protected String getProtectedInfo() {
return "Species: " + protectedSpecies + ", Secret: " + privateSecret;
}
// 🎯 Public method exposing controlled access to private data
public void revealSecret() {
privateMethod(); // Can call private method from within class
System.out.println("Revealing secret: " + privateSecret);
}
// 🎯 Demonstration of access within same class
public void demonstrateInternalAccess() {
System.out.println("\n=== INTERNAL ACCESS DEMONSTRATION ===");
System.out.println("Accessing all fields from within the same class:");
System.out.println("Public: " + publicName);
System.out.println("Protected: " + protectedSpecies);
System.out.println("Default: " + defaultHabitat);
System.out.println("Private: " + privateSecret);
// Calling all methods from within same class
publicMethod();
protectedMethod();
defaultMethod();
privateMethod();
}
}
// File: Dog.java (Same package as Animal)
class Dog extends Animal {
private String breed;
public Dog(String name, String breed) {
super(name, "Canine", "Domestic");
this.breed = breed;
}
// 🎯 Can access protected members from parent class
public void displayProtectedInfo() {
System.out.println("Accessing protected member from subclass: " + protectedSpecies);
protectedMethod(); // Can call protected method
}
// 🎯 Can access default members (same package)
public void displayDefaultInfo() {
System.out.println("Accessing default member in same package: " + defaultHabitat);
defaultMethod(); // Can call default method
}
// 🎯 CANNOT access private members from parent class
public void tryAccessPrivate() {
// ❌ This would cause compilation error:
// System.out.println(privateSecret); 
// privateMethod();
System.out.println("Cannot access private members from subclass");
}
public void demonstrateSubclassAccess() {
System.out.println("\n=== SUBCLASS ACCESS DEMONSTRATION ===");
System.out.println("Public access: " + publicName);
System.out.println("Protected access: " + protectedSpecies);
System.out.println("Default access: " + defaultHabitat);
// Private access: NOT POSSIBLE
}
}
// File: AnimalDemo.java (Same package - demonstrating package access)
public class AnimalDemo {
public static void main(String[] args) {
System.out.println("=== ACCESS MODIFIERS DEMONSTRATION ===");
Animal lion = new Animal("Leo", "Lion", "Savannah");
// 🎯 PUBLIC ACCESS - Available everywhere
System.out.println("1. PUBLIC ACCESS:");
System.out.println("Name: " + lion.publicName);
lion.publicMethod();
// 🎯 PROTECTED ACCESS - Available in same package
System.out.println("\n2. PROTECTED ACCESS (same package):");
System.out.println("Species: " + lion.protectedSpecies);
lion.protectedMethod();
// 🎯 DEFAULT ACCESS - Available in same package
System.out.println("\n3. DEFAULT ACCESS (same package):");
System.out.println("Habitat: " + lion.defaultHabitat);
lion.defaultMethod();
// 🎯 PRIVATE ACCESS - NOT available outside class
System.out.println("\n4. PRIVATE ACCESS (outside class):");
// ❌ These would cause compilation errors:
// System.out.println(lion.privateSecret);
// lion.privateMethod();
System.out.println("Private members are not accessible outside the class");
// Using public methods to access private data (ENCAPSULATION)
lion.revealSecret();
// 🎯 Demonstration with subclass
System.out.println("\n" + "=".repeat(50));
Dog buddy = new Dog("Buddy", "Golden Retriever");
buddy.demonstrateSubclassAccess();
buddy.displayProtectedInfo();
buddy.displayDefaultInfo();
// 🎯 Internal access demonstration
System.out.println("\n" + "=".repeat(50));
lion.demonstrateInternalAccess();
}
}

Output:

=== ACCESS MODIFIERS DEMONSTRATION ===
1. PUBLIC ACCESS:
Name: Leo
Public method - anyone can call me!
2. PROTECTED ACCESS (same package):
Species: Lion
Protected method - package and subclasses only
3. DEFAULT ACCESS (same package):
Habitat: Savannah
Default method - same package only
4. PRIVATE ACCESS (outside class):
Private members are not accessible outside the class
Private method - only I can call myself!
Revealing secret: Classified information
==================================================
=== SUBCLASS ACCESS DEMONSTRATION ===
Public access: Buddy
Protected access: Canine
Default access: Domestic
Accessing protected member from subclass: Canine
Protected method - package and subclasses only
Accessing default member in same package: Domestic
Default method - same package only
==================================================
=== INTERNAL ACCESS DEMONSTRATION ===
Accessing all fields from within the same class:
Public: Leo
Protected: Lion
Default: Savannah
Private: Classified information
Public method - anyone can call me!
Protected method - package and subclasses only
Default method - same package only
Private method - only I can call myself!

Example 2: Cross-Package Access Demonstration

// File: com/company/vehicle/Car.java
package com.company.vehicle;
public class Car {
// Different access modifiers
public String publicModel;
protected String protectedEngine;
String defaultColor; // package-private
private String privateVIN;
public Car(String model, String engine, String color, String vin) {
this.publicModel = model;
this.protectedEngine = engine;
this.defaultColor = color;
this.privateVIN = vin;
}
// Public method
public void displayPublicInfo() {
System.out.println("Model: " + publicModel);
}
// Protected method
protected void displayProtectedInfo() {
System.out.println("Engine: " + protectedEngine);
}
// Default method
void displayDefaultInfo() {
System.out.println("Color: " + defaultColor);
}
// Private method
private void displayPrivateInfo() {
System.out.println("VIN: " + privateVIN);
}
// Public method that uses private members
public void getCarDetails() {
System.out.println("Car: " + publicModel + ", " + protectedEngine + ", " + defaultColor);
displayPrivateInfo(); // Internal access to private method
}
}
// File: com/company/vehicle/SportsCar.java (Same package - extends Car)
package com.company.vehicle;
public class SportsCar extends Car {
private int topSpeed;
public SportsCar(String model, String engine, String color, String vin, int topSpeed) {
super(model, engine, color, vin);
this.topSpeed = topSpeed;
}
public void demonstrateAccess() {
System.out.println("=== SUBCLASS IN SAME PACKAGE ===");
// ✅ PUBLIC - Always accessible
System.out.println("Public: " + publicModel);
displayPublicInfo();
// ✅ PROTECTED - Accessible to subclasses
System.out.println("Protected: " + protectedEngine);
displayProtectedInfo();
// ✅ DEFAULT - Accessible in same package
System.out.println("Default: " + defaultColor);
displayDefaultInfo();
// ❌ PRIVATE - Not accessible
// System.out.println(privateVIN);
// displayPrivateInfo();
}
}
// File: com/company/management/Garage.java (Different package)
package com.company.management;
import com.company.vehicle.Car;
public class Garage {
public void maintainCar(Car car) {
System.out.println("=== DIFFERENT PACKAGE ACCESS ===");
// ✅ PUBLIC - Accessible from anywhere
System.out.println("Public: " + car.publicModel);
car.displayPublicInfo();
// ❌ PROTECTED - Not accessible from different package (unless subclass)
// System.out.println(car.protectedEngine);
// car.displayProtectedInfo();
// ❌ DEFAULT - Not accessible from different package
// System.out.println(car.defaultColor);
// car.displayDefaultInfo();
// ❌ PRIVATE - Never accessible outside class
// System.out.println(car.privateVIN);
// car.displayPrivateInfo();
System.out.println("Only public members are accessible from different package");
}
}
// File: com/company/management/FleetManager.java (Different package - extends Car)
package com.company.management;
import com.company.vehicle.Car;
public class FleetManager extends Car {
private int fleetSize;
public FleetManager(String model, String engine, String color, String vin, int fleetSize) {
super(model, engine, color, vin);
this.fleetSize = fleetSize;
}
public void demonstrateCrossPackageAccess() {
System.out.println("=== SUBCLASS IN DIFFERENT PACKAGE ===");
// ✅ PUBLIC - Always accessible
System.out.println("Public: " + publicModel);
displayPublicInfo();
// ✅ PROTECTED - Accessible to subclasses (even in different packages)
System.out.println("Protected: " + protectedEngine);
displayProtectedInfo();
// ❌ DEFAULT - Not accessible from different package
// System.out.println(defaultColor);
// displayDefaultInfo();
// ❌ PRIVATE - Never accessible outside class
// System.out.println(privateVIN);
// displayPrivateInfo();
}
// Special case: accessing through 'this' reference
public void accessThroughThis() {
System.out.println("Access through 'this' reference:");
System.out.println("Public: " + this.publicModel);
System.out.println("Protected: " + this.protectedEngine);
// Default and private still not accessible
}
}
// File: com/company/Main.java (Main class to demonstrate everything)
package com.company;
import com.company.vehicle.Car;
import com.company.vehicle.SportsCar;
import com.company.management.Garage;
import com.company.management.FleetManager;
public class Main {
public static void main(String[] args) {
System.out.println("=== CROSS-PACKAGE ACCESS MODIFIERS DEMO ===");
// Create instances
Car myCar = new Car("Sedan", "V6", "Blue", "12345");
SportsCar sportsCar = new SportsCar("Ferrari", "V8", "Red", "67890", 200);
Garage garage = new Garage();
FleetManager manager = new FleetManager("SUV", "V4", "Black", "11111", 10);
// 🎯 Same package access
System.out.println("\n1. SAME PACKAGE ACCESS:");
sportsCar.demonstrateAccess();
// 🎯 Different package access (non-subclass)
System.out.println("\n2. DIFFERENT PACKAGE ACCESS (Non-subclass):");
garage.maintainCar(myCar);
// 🎯 Different package access (subclass)
System.out.println("\n3. DIFFERENT PACKAGE ACCESS (Subclass):");
manager.demonstrateCrossPackageAccess();
manager.accessThroughThis();
// 🎯 Direct access demonstration
System.out.println("\n4. DIRECT ACCESS FROM MAIN:");
System.out.println("Public: " + myCar.publicModel);
myCar.displayPublicInfo();
// Other access levels not available from main (different package)
}
}

Output:

=== CROSS-PACKAGE ACCESS MODIFIERS DEMO ===
1. SAME PACKAGE ACCESS:
=== SUBCLASS IN SAME PACKAGE ===
Public: Ferrari
Model: Ferrari
Protected: V8
Engine: V8
Default: Red
Color: Red
2. DIFFERENT PACKAGE ACCESS (Non-subclass):
=== DIFFERENT PACKAGE ACCESS ===
Public: Sedan
Model: Sedan
Only public members are accessible from different package
3. DIFFERENT PACKAGE ACCESS (Subclass):
=== SUBCLASS IN DIFFERENT PACKAGE ===
Public: SUV
Model: SUV
Protected: V4
Engine: V4
Access through 'this' reference:
Public: SUV
Protected: V4
4. DIRECT ACCESS FROM MAIN:
Public: Sedan
Model: Sedan

Example 3: Real-World Encapsulation with Access Modifiers

// File: BankAccount.java
public class BankAccount {
// 🎯 PRIVATE: Internal implementation details (ENCAPSULATION)
private String accountNumber;
private double balance;
private String accountHolder;
private String socialSecurityNumber;
private boolean isActive;
// 🎯 PUBLIC: Constructor - needed to create objects
public BankAccount(String accountHolder, String ssn, String accountNumber) {
this.accountHolder = accountHolder;
this.socialSecurityNumber = ssn;
this.accountNumber = accountNumber;
this.balance = 0.0;
this.isActive = true;
}
// 🎯 PUBLIC: Methods that define the interface (what users can do)
public void deposit(double amount) {
if (amount > 0 && isActive) {
balance += amount;
System.out.println("Deposited: $" + amount);
logTransaction("DEPOSIT", amount);
} else {
System.out.println("Invalid deposit amount or inactive account");
}
}
public boolean withdraw(double amount) {
if (amount > 0 && balance >= amount && isActive) {
balance -= amount;
System.out.println("Withdrawn: $" + amount);
logTransaction("WITHDRAW", amount);
return true;
}
System.out.println("Insufficient funds or invalid amount");
return false;
}
public double getBalance() {
return balance;
}
public String getAccountInfo() {
return "Account: " + accountNumber + ", Holder: " + accountHolder + ", Balance: $" + balance;
}
// 🎯 PROTECTED: Methods for internal bank operations
protected void applyInterest(double rate) {
if (isActive && rate > 0) {
double interest = balance * rate / 100;
balance += interest;
System.out.println("Interest applied: $" + interest);
}
}
protected void freezeAccount() {
isActive = false;
System.out.println("Account frozen");
}
protected void unfreezeAccount() {
isActive = true;
System.out.println("Account unfrozen");
}
// 🎯 PRIVATE: Internal helper methods (implementation details)
private void logTransaction(String type, double amount) {
System.out.println("[LOG] " + type + ": $" + amount + " | Balance: $" + balance);
}
private boolean isValidAmount(double amount) {
return amount > 0;
}
// 🎯 DEFAULT: Package-level operations
void internalAudit() {
System.out.println("[AUDIT] Account: " + accountNumber + ", Balance: $" + balance);
}
// 🎯 Demonstration of encapsulation benefits
public void demonstrateEncapsulation() {
System.out.println("\n=== ENCAPSULATION BENEFITS ===");
System.out.println("1. Data Protection: Balance can only be modified through controlled methods");
System.out.println("2. Validation: All operations validate input before modifying state");
System.out.println("3. Flexibility: Internal implementation can change without affecting users");
System.out.println("4. Security: Sensitive data (SSN) is completely hidden");
}
}
// File: SavingsAccount.java (Extends BankAccount)
public class SavingsAccount extends BankAccount {
private double interestRate;
public SavingsAccount(String accountHolder, String ssn, String accountNumber, double interestRate) {
super(accountHolder, ssn, accountNumber);
this.interestRate = interestRate;
}
// 🎯 Can access protected method from parent
public void applyAnnualInterest() {
applyInterest(interestRate); // Protected method accessible to subclass
System.out.println("Annual interest applied at rate: " + interestRate + "%");
}
// 🎯 CANNOT access private members from parent
public void tryAccessPrivate() {
// ❌ These would cause compilation errors:
// System.out.println(balance); // private
// System.out.println(socialSecurityNumber); // private
// logTransaction("TEST", 100); // private
System.out.println("Cannot access private members from subclass");
}
// 🎯 Override with additional functionality
@Override
public boolean withdraw(double amount) {
// Savings account might have withdrawal limits
if (amount > 1000) {
System.out.println("Withdrawal limit exceeded for savings account");
return false;
}
return super.withdraw(amount);
}
}
// File: Bank.java (Same package - demonstrates package access)
public class Bank {
private String bankName;
public Bank(String bankName) {
this.bankName = bankName;
}
// 🎯 Can access default methods in same package
public void performMonthlyAudit(BankAccount account) {
System.out.println("\n=== MONTHLY AUDIT for " + bankName + " ===");
account.internalAudit(); // Default method accessible in same package
}
// 🎯 Can access protected methods in same package
public void handleFraudCase(BankAccount account) {
System.out.println("\n=== FRAUD HANDLING ===");
account.freezeAccount(); // Protected method accessible in same package
}
public void demonstratePackageAccess() {
System.out.println("\n=== PACKAGE-LEVEL ACCESS ===");
BankAccount account = new BankAccount("John Doe", "123-45-6789", "ACC123");
// Can access public, protected, and default members in same package
account.deposit(1000);
account.internalAudit(); // Default access
account.applyInterest(2.5); // Protected access
}
}
// File: BankDemo.java (Main demonstration class)
public class BankDemo {
public static void main(String[] args) {
System.out.println("=== BANK ACCOUNT ENCAPSULATION DEMO ===");
// Create accounts
BankAccount checking = new BankAccount("Alice Smith", "987-65-4321", "CHK001");
SavingsAccount savings = new SavingsAccount("Bob Johnson", "456-78-9012", "SAV001", 2.5);
Bank cityBank = new Bank("City Bank");
// 🎯 Public interface usage
System.out.println("\n1. PUBLIC INTERFACE USAGE:");
checking.deposit(1500);
checking.withdraw(200);
System.out.println("Balance: $" + checking.getBalance());
System.out.println(checking.getAccountInfo());
// 🎯 Savings account with protected access
System.out.println("\n2. SAVINGS ACCOUNT OPERATIONS:");
savings.deposit(5000);
savings.applyAnnualInterest(); // Uses protected method
System.out.println("Savings balance: $" + savings.getBalance());
// 🎯 Package-level access demonstration
System.out.println("\n3. PACKAGE-LEVEL OPERATIONS:");
cityBank.performMonthlyAudit(checking);
cityBank.demonstratePackageAccess();
// 🎯 Encapsulation benefits
System.out.println("\n4. ENCAPSULATION IN ACTION:");
checking.demonstrateEncapsulation();
// 🎯 Attempting invalid operations (prevented by encapsulation)
System.out.println("\n5. INVALID OPERATIONS (PREVENTED):");
// ❌ Direct access to private fields not allowed
// checking.balance = 1000000; // Compilation error
// checking.socialSecurityNumber = "hacked"; // Compilation error
// ✅ Must use public methods with validation
checking.deposit(-100); // Invalid - rejected
checking.withdraw(1000000); // Invalid - rejected
// 🎯 Security demonstration
System.out.println("\n6. SECURITY FEATURES:");
System.out.println("Sensitive data (SSN) is completely hidden from external access");
System.out.println("Balance can only be modified through validated methods");
System.out.println("Internal logging and auditing are hidden implementation details");
}
}

Output:

=== BANK ACCOUNT ENCAPSULATION DEMO ===
1. PUBLIC INTERFACE USAGE:
Deposited: $1500.0
[LOG] DEPOSIT: $1500.0 | Balance: $1500.0
Withdrawn: $200.0
[LOG] WITHDRAW: $200.0 | Balance: $1300.0
Balance: $1300.0
Account: CHK001, Holder: Alice Smith, Balance: $1300.0
2. SAVINGS ACCOUNT OPERATIONS:
Deposited: $5000.0
[LOG] DEPOSIT: $5000.0 | Balance: $5000.0
Interest applied: $125.0
Annual interest applied at rate: 2.5%
Savings balance: $5125.0
3. PACKAGE-LEVEL OPERATIONS:
=== MONTHLY AUDIT for City Bank ===
[AUDIT] Account: CHK001, Balance: $1300.0
=== PACKAGE-LEVEL ACCESS ===
Deposited: $1000.0
[LOG] DEPOSIT: $1000.0 | Balance: $1000.0
[AUDIT] Account: ACC123, Balance: $1000.0
Interest applied: $25.0
4. ENCAPSULATION IN ACTION:
=== ENCAPSULATION BENEFITS ===
1. Data Protection: Balance can only be modified through controlled methods
2. Validation: All operations validate input before modifying state
3. Flexibility: Internal implementation can change without affecting users
4. Security: Sensitive data (SSN) is completely hidden
5. INVALID OPERATIONS (PREVENTED):
Invalid deposit amount or inactive account
Insufficient funds or invalid amount
6. SECURITY FEATURES:
Sensitive data (SSN) is completely hidden from external access
Balance can only be modified through validated methods
Internal logging and auditing are hidden implementation details

Example 4: Access Modifiers with Constructors and Static Members

// File: Student.java
public class Student {
// 🎯 Instance variables with different access levels
public String publicName;
protected int protectedAge;
String defaultGrade; // package-private
private String privateEmail;
// 🎯 Static variables with different access levels
public static String publicSchool = "Public High School";
protected static int protectedStudentCount = 0;
static String defaultPrincipal = "John Smith"; // package-private
private static String privateSchoolMotto = "Knowledge is Power";
// 🎯 CONSTRUCTORS with different access levels
// Public constructor - anyone can create Student objects
public Student(String name, int age, String grade, String email) {
this.publicName = name;
this.protectedAge = age;
this.defaultGrade = grade;
this.privateEmail = email;
protectedStudentCount++;
}
// Protected constructor - only subclasses and same package can use
protected Student(String name, int age) {
this(name, age, "Unknown", "[email protected]");
}
// Default constructor - only same package can use
Student(String name) {
this(name, 0, "Unknown", "[email protected]");
}
// Private constructor - only this class can use (for singleton/factory patterns)
private Student() {
this("Anonymous", 0, "Unknown", "[email protected]");
}
// 🎯 Static factory method using private constructor
public static Student createAnonymousStudent() {
return new Student(); // Can use private constructor within class
}
// 🎯 METHODS with different access levels
// Public method
public void displayPublicInfo() {
System.out.println("Student: " + publicName + ", Grade: " + defaultGrade);
}
// Protected method
protected void displayProtectedInfo() {
System.out.println("Age: " + protectedAge + ", Email: " + privateEmail);
}
// Default method
void displayDefaultInfo() {
System.out.println("All info: " + publicName + ", " + protectedAge + ", " + defaultGrade);
}
// Private method
private void displayPrivateInfo() {
System.out.println("Private email: " + privateEmail);
}
// 🎯 Static methods with different access levels
public static void displayPublicStaticInfo() {
System.out.println("School: " + publicSchool + ", Students: " + protectedStudentCount);
}
protected static void displayProtectedStaticInfo() {
System.out.println("Principal: " + defaultPrincipal + ", Motto: " + privateSchoolMotto);
}
static void displayDefaultStaticInfo() {
System.out.println("School info: " + publicSchool + ", " + defaultPrincipal);
}
private static void displayPrivateStaticInfo() {
System.out.println("Secret motto: " + privateSchoolMotto);
}
// 🎯 Public method that uses private static members
public static void revealMotto() {
displayPrivateStaticInfo();
}
// 🎯 Demonstration method
public void demonstrateAccess() {
System.out.println("\n=== INTERNAL ACCESS DEMONSTRATION ===");
// Instance members
System.out.println("Public: " + publicName);
System.out.println("Protected: " + protectedAge);
System.out.println("Default: " + defaultGrade);
System.out.println("Private: " + privateEmail);
// Static members
System.out.println("Public Static: " + publicSchool);
System.out.println("Protected Static: " + protectedStudentCount);
System.out.println("Default Static: " + defaultPrincipal);
System.out.println("Private Static: " + privateSchoolMotto);
}
}
// File: CollegeStudent.java (Subclass)
public class CollegeStudent extends Student {
private String major;
// Can use public and protected constructors
public CollegeStudent(String name, int age, String grade, String email, String major) {
super(name, age, grade, email); // Public constructor
this.major = major;
}
// Can use protected constructor
public CollegeStudent(String name, int age, String major) {
super(name, age); // Protected constructor
this.major = major;
}
// ❌ Cannot use default or private constructors from different package
// public CollegeStudent(String name) {
//     super(name); // Default constructor - not accessible
// }
public void demonstrateSubclassAccess() {
System.out.println("=== SUBCLASS ACCESS ===");
// Instance members
System.out.println("Public: " + publicName);
System.out.println("Protected: " + protectedAge);
// System.out.println(defaultGrade); // Not accessible (different package)
// System.out.println(privateEmail); // Not accessible
// Static members
System.out.println("Public Static: " + publicSchool);
System.out.println("Protected Static: " + protectedStudentCount);
// System.out.println(defaultPrincipal); // Not accessible
// System.out.println(privateSchoolMotto); // Not accessible
}
// Can access protected methods
public void showProtectedInfo() {
displayProtectedInfo(); // Protected method accessible
}
}
// File: School.java (Same package demonstration)
class School {
public void demonstratePackageAccess() {
System.out.println("=== SAME PACKAGE ACCESS ===");
// Can use public, protected, and default constructors
Student student1 = new Student("John", 16, "10th", "[email protected]"); // Public
Student student2 = new Student("Jane", 15); // Protected
Student student3 = new Student("Mike"); // Default
// Student student4 = new Student(); // Private - not accessible
// Accessing members
System.out.println("Public: " + student1.publicName);
System.out.println("Protected: " + student1.protectedAge);
System.out.println("Default: " + student1.defaultGrade);
// System.out.println(student1.privateEmail); // Not accessible
// Calling methods
student1.displayPublicInfo();
student1.displayProtectedInfo();
student1.displayDefaultInfo();
// student1.displayPrivateInfo(); // Not accessible
// Static access
System.out.println("Public Static: " + Student.publicSchool);
System.out.println("Protected Static: " + Student.protectedStudentCount);
System.out.println("Default Static: " + Student.defaultPrincipal);
// System.out.println(Student.privateSchoolMotto); // Not accessible
}
}
// File: AccessModifiersDemo.java (Main class)
public class AccessModifiersDemo {
public static void main(String[] args) {
System.out.println("=== ACCESS MODIFIERS WITH CONSTRUCTORS AND STATIC ===");
// 🎯 Creating objects with different constructors
Student student1 = new Student("Alice", 17, "11th", "[email protected]");
Student anonymous = Student.createAnonymousStudent();
// 🎯 Access demonstration
student1.demonstrateAccess();
// 🎯 Static access demonstration
System.out.println("\n=== STATIC MEMBER ACCESS ===");
System.out.println("Public static: " + Student.publicSchool);
Student.displayPublicStaticInfo();
// 🎯 Subclass demonstration
System.out.println("\n=== SUBCLASS ACCESS ===");
CollegeStudent collegeStudent = new CollegeStudent("Bob", 20, "A", "[email protected]", "Computer Science");
collegeStudent.demonstrateSubclassAccess();
collegeStudent.showProtectedInfo();
// 🎯 Same package demonstration
System.out.println("\n=== SAME PACKAGE ACCESS ===");
School school = new School();
school.demonstratePackageAccess();
// 🎯 Constructor access summary
System.out.println("\n=== CONSTRUCTOR ACCESS SUMMARY ===");
System.out.println("Public constructor: Accessible from anywhere");
System.out.println("Protected constructor: Accessible in package + subclasses");
System.out.println("Default constructor: Accessible only in same package");
System.out.println("Private constructor: Accessible only within same class");
// 🎯 Static access summary
System.out.println("\n=== STATIC MEMBER ACCESS SUMMARY ===");
System.out.println("Follows the same rules as instance members");
System.out.println("Accessed through ClassName.memberName");
}
}

Output:

=== ACCESS MODIFIERS WITH CONSTRUCTORS AND STATIC ===
=== INTERNAL ACCESS DEMONSTRATION ===
Public: Alice
Protected: 17
Default: 11th
Private: [email protected]
Public Static: Public High School
Protected Static: 2
Default Static: John Smith
Private Static: Knowledge is Power
=== STATIC MEMBER ACCESS ===
Public static: Public High School
School: Public High School, Students: 2
=== SUBCLASS ACCESS ===
=== SUBCLASS ACCESS ===
Public: Bob
Protected: 20
Public Static: Public High School
Protected Static: 3
Age: 20, Email: [email protected]
=== SAME PACKAGE ACCESS ===
=== SAME PACKAGE ACCESS ===
Public: John
Protected: 16
Default: 10th
Student: John, Grade: 10th
Age: 16, Email: [email protected]
All info: John, 16, 10th
Public Static: Public High School
Protected Static: 6
Default Static: John Smith
=== CONSTRUCTOR ACCESS SUMMARY ===
Public constructor: Accessible from anywhere
Protected constructor: Accessible in package + subclasses
Default constructor: Accessible only in same package
Private constructor: Accessible only within same class
=== STATIC MEMBER ACCESS SUMMARY ===
Follows the same rules as instance members
Accessed through ClassName.memberName

---

Access Modifiers Summary Table

Modifier	Class	Package	Subclass	World	Typical Use
private	✅	❌	❌	❌	Internal implementation, sensitive data
default	✅	✅	❌	❌	Package-level utilities, internal APIs
protected	✅	✅	✅	❌	Framework hooks, subclass customization
public	✅	✅	✅	✅	Public API, interfaces, constants

---

Best Practices

1. Use the most restrictive access level possible - start with private and increase as needed
2. Make fields private and provide public getters/setters for encapsulation
3. Use public for API methods that users need to call
4. Use protected for methods meant to be overridden by subclasses
5. Use package-private (default) for internal implementation details
6. Keep constructors private for singleton patterns or factory methods
7. Use public static final for constants

---

Common Patterns

Encapsulation Pattern:

public class BankAccount {
private double balance;
public double getBalance() { return balance; }
public void deposit(double amount) { 
if (amount > 0) balance += amount; 
}
}

Singleton Pattern:

public class Singleton {
private static Singleton instance;
private Singleton() {} // Private constructor
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}

Factory Pattern:

public class AnimalFactory {
private AnimalFactory() {} // Private constructor
public static Animal createAnimal(String type) {
switch (type) {
case "dog": return new Dog();
case "cat": return new Cat();
default: throw new IllegalArgumentException();
}
}
}

---

Conclusion

Access modifiers are fundamental to Java's object-oriented design:

• ✅ Enable encapsulation by hiding implementation details
• ✅ Provide security by controlling access to sensitive data
• ✅ Support maintainability by defining clear APIs
• ✅ Facilitate code organization through package structuring

Key Takeaways:

1. private - Class-level privacy (most restrictive)
2. default - Package-level privacy (no modifier)
3. protected - Package + subclass access
4. public - Global access (least restrictive)

Remember: Good access modifier usage is like good architecture - it creates clear boundaries, protects what's important, and makes the system more maintainable and secure. Choose your access levels thoughtfully! 🏗️🔒

Now you have a comprehensive understanding of how to control visibility and build well-encapsulated Java applications!