Introduction
Imagine you're in a family where some things are shared freely among family members (same package), but aren't automatically available to neighbors or strangers (other packages). That's exactly how the default access modifier works in Java—it's like having "family-only" access for your classes, methods, and variables!
The default access modifier (also called package-private) is what you get when you don't specify any access modifier. It's Java's way of saying "this is for internal use within this package only."
What is the Default Access Modifier?
The default access modifier is the access level you get when you don't explicitly declare any access modifier (public, private, or protected). It provides package-level access, meaning the member is accessible only within its own package.
Key Characteristics:
- ✅ Package-private: Accessible only within the same package
- ✅ No keyword: No explicit modifier needed
- ✅ Default behavior: What you get when you don't specify access
- ✅ Encapsulation: Helps with package-level encapsulation
- ✅ Simple: Easy to use for internal package components
Access Modifier Comparison
| Access Modifier | Same Class | Same Package | Subclass | Other Packages |
|---|---|---|---|---|
private | ✅ Yes | ❌ No | ❌ No | ❌ No |
default | ✅ Yes | ✅ Yes | ❌ No | ❌ No |
protected | ✅ Yes | ✅ Yes | ✅ Yes | ❌ No |
public | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes |
Code Explanation with Examples
Example 1: Basic Default Access Modifier
// File 1: DefaultAccessDemo.java
package com.mypackage;
public class DefaultAccessDemo {
public static void main(String[] args) {
System.out.println("=== DEFAULT ACCESS MODIFIER DEMO ===");
// Create instances of classes in the same package
Person person = new Person("John", 25);
Employee employee = new Employee("Alice", "IT");
// ✅ Can access default methods and variables in same package
person.displayInfo(); // Default method - accessible
employee.showDetails(); // Default method - accessible
// ✅ Can access default variables in same package
System.out.println("Person name: " + person.name); // Default variable
System.out.println("Employee dept: " + employee.department); // Default variable
// ✅ Can call default methods
person.setAge(26); // Default method
System.out.println("Updated age: " + person.getAge()); // Public method
}
}
// Default access class (no public modifier)
class Person {
// Default access instance variables
String name; // Default access
int age; // Default access
// Default access constructor
Person(String name, int age) {
this.name = name;
this.age = age;
}
// Default access method
void displayInfo() {
System.out.println("Person: " + name + ", Age: " + age);
}
// Default access method
void setAge(int age) {
this.age = age;
}
// Public method - accessible from anywhere
public int getAge() {
return age;
}
}
// Another class in same package
class Employee {
String name; // Default access
String department; // Default access
// Default access constructor
Employee(String name, String department) {
this.name = name;
this.department = department;
}
// Default access method
void showDetails() {
System.out.println("Employee: " + name + ", Department: " + department);
}
}
Output:
=== DEFAULT ACCESS MODIFIER DEMO === Person: John, Age: 25 Employee: Alice, Department: IT Person name: John Employee dept: IT Updated age: 26
Example 2: Package Structure Demonstration
Let's create a package structure to demonstrate default access:
Directory Structure:
src/ ├── com/ │ ├── mypackage/ │ │ ├── PackageA.java │ │ ├── ClassA.java │ │ └── ClassB.java │ └── otherpackage/ │ ├── PackageB.java │ └── ClassC.java
// File 1: com/mypackage/PackageA.java
package com.mypackage;
public class PackageA {
public static void main(String[] args) {
System.out.println("=== SAME PACKAGE ACCESS ===");
// ✅ All these are accessible in same package
ClassA objA = new ClassA();
ClassB objB = new ClassB();
// Access default members from ClassA
objA.defaultMethod(); // Default method
System.out.println("ClassA default variable: " + objA.defaultVariable);
// Access default members from ClassB
objB.displayInfo(); // Default method
System.out.println("ClassB data: " + objB.data);
// Access protected members (also accessible in same package)
objA.protectedMethod();
System.out.println("ClassA protected variable: " + objA.protectedVariable);
}
}
// File 2: com/mypackage/ClassA.java
package com.mypackage;
class ClassA { // Default access class
// Different access modifiers for demonstration
int defaultVariable = 10; // Default access
protected int protectedVariable = 20; // Protected access
public int publicVariable = 30; // Public access
private int privateVariable = 40; // Private access
// Default access constructor
ClassA() {
System.out.println("ClassA default constructor called");
}
// Default access method
void defaultMethod() {
System.out.println("ClassA default method - package access only");
System.out.println("Can access private variable: " + privateVariable);
}
// Protected method
protected void protectedMethod() {
System.out.println("ClassA protected method");
}
// Public method
public void publicMethod() {
System.out.println("ClassA public method");
}
// Private method
private void privateMethod() {
System.out.println("ClassA private method");
}
// Public getter for private variable
public int getPrivateVariable() {
return privateVariable;
}
}
// File 3: com/mypackage/ClassB.java
package com.mypackage;
class ClassB { // Default access class
String data = "Default access data";
// Default access method
void displayInfo() {
System.out.println("ClassB: " + data);
// Can access other default class in same package
ClassA classA = new ClassA();
classA.defaultMethod(); // ✅ Accessible - same package
classA.protectedMethod(); // ✅ Accessible - same package
classA.publicMethod(); // ✅ Accessible - always
}
}
// File 4: com/otherpackage/PackageB.java
package com.otherpackage;
import com.mypackage.ClassA; // Can import public class
// import com.mypackage.ClassB; // ❌ Cannot import - ClassB has default access
public class PackageB {
public static void main(String[] args) {
System.out.println("=== DIFFERENT PACKAGE ACCESS ===");
// ✅ Can access public class from different package
ClassA objA = new ClassA();
// ✅ Public members are accessible
objA.publicMethod();
System.out.println("Public variable: " + objA.publicVariable);
// ❌ DEFAULT members are NOT accessible from different package
// objA.defaultMethod(); // Compilation error
// System.out.println(objA.defaultVariable); // Compilation error
// ❌ PROTECTED members are NOT accessible from different package (unless subclass)
// objA.protectedMethod(); // Compilation error
// System.out.println(objA.protectedVariable); // Compilation error
// ❌ PRIVATE members are never accessible
// objA.privateMethod(); // Compilation error
// System.out.println(objA.privateVariable); // Compilation error
// ✅ But can use public getter for private variable
System.out.println("Private variable via getter: " + objA.getPrivateVariable());
// ❌ Cannot access default class from different package
// ClassB objB = new ClassB(); // Compilation error - ClassB not visible
}
}
// File 5: com/otherpackage/ClassC.java
package com.otherpackage;
// Cannot extend ClassB because it has default access
// class ClassC extends ClassB { } // ❌ Compilation error
// Can extend ClassA because it's public
class ClassC extends com.mypackage.ClassA {
public void testAccess() {
System.out.println("=== SUBCLASS IN DIFFERENT PACKAGE ===");
// ✅ Public members accessible
publicMethod();
System.out.println("Public variable: " + publicVariable);
// ✅ Protected members accessible to subclasses
protectedMethod();
System.out.println("Protected variable: " + protectedVariable);
// ❌ DEFAULT members NOT accessible from different package
// defaultMethod(); // Compilation error
// System.out.println(defaultVariable); // Compilation error
// ❌ PRIVATE members never accessible
// privateMethod(); // Compilation error
// System.out.println(privateVariable); // Compilation error
}
}
Output for PackageA:
=== SAME PACKAGE ACCESS === ClassA default constructor called ClassA default constructor called ClassA default method - package access only Can access private variable: 40 ClassA default variable: 10 ClassB: Default access data ClassA default constructor called ClassA default method - package access only Can access private variable: 40 ClassA protected method ClassA protected variable: 20
Output for PackageB:
=== DIFFERENT PACKAGE ACCESS === ClassA public method Public variable: 30 Private variable via getter: 40
Example 3: Real-World Package Organization
// File 1: com/company/bank/Account.java
package com.company.bank;
// Public class - accessible from outside package
public class Account {
private String accountNumber;
private double balance;
String accountType; // Default access - internal package use only
protected String currency; // Protected - for subclasses
// Default access constructor - for internal package use
Account(String accountNumber, String accountType) {
this.accountNumber = accountNumber;
this.accountType = accountType;
this.balance = 0.0;
this.currency = "USD";
}
// Public methods - external interface
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("Deposited: $" + amount);
}
}
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("Withdrawn: $" + amount);
}
}
public double getBalance() {
return balance;
}
public String getAccountNumber() {
return accountNumber;
}
// Default access method - internal package use
void internalAccountUpdate(String newType) {
this.accountType = newType;
System.out.println("Account type updated to: " + newType);
}
// Protected method - for subclasses
protected void setCurrency(String currency) {
this.currency = currency;
}
}
// File 2: com/company/bank/BankManager.java
package com.company.bank;
// Default access class - internal to bank package
class BankManager {
private String managerId;
// Default access constructor
BankManager(String managerId) {
this.managerId = managerId;
}
// Default access method - can access all Account's default members
void reviewAccount(Account account) {
System.out.println("Manager " + managerId + " reviewing account:");
System.out.println("Account #: " + account.getAccountNumber());
System.out.println("Account Type: " + account.accountType); // ✅ Default access
System.out.println("Balance: $" + account.getBalance());
// Can call default method
account.internalAccountUpdate("PREMIUM"); // ✅ Default access
}
// Internal package utility method
void generateInternalReport(Account[] accounts) {
System.out.println("\n=== INTERNAL BANK REPORT ===");
for (Account acc : accounts) {
System.out.println(acc.getAccountNumber() + " - " +
acc.accountType + " - $" + acc.getBalance());
}
}
}
// File 3: com/company/bank/Bank.java
package com.company.bank;
import java.util.ArrayList;
import java.util.List;
// Public class - main bank interface
public class Bank {
private List<Account> accounts;
private BankManager manager; // Default access class - usable in same package
public Bank() {
this.accounts = new ArrayList<>();
this.manager = new BankManager("MGR001"); // ✅ Can create - same package
}
public void openAccount(String accountNumber, String accountType) {
// Using default constructor of Account - ✅ accessible in same package
Account newAccount = new Account(accountNumber, accountType);
accounts.add(newAccount);
System.out.println("New account opened: " + accountNumber);
}
public void managerReview(String accountNumber) {
Account account = findAccount(accountNumber);
if (account != null) {
manager.reviewAccount(account); // ✅ Default method accessible
}
}
public void generateReport() {
Account[] accountArray = accounts.toArray(new Account[0]);
manager.generateInternalReport(accountArray); // ✅ Default method accessible
}
private Account findAccount(String accountNumber) {
return accounts.stream()
.filter(acc -> acc.getAccountNumber().equals(accountNumber))
.findFirst()
.orElse(null);
}
}
// File 4: com/company/bank/SavingsAccount.java
package com.company.bank;
// Public subclass in same package
public class SavingsAccount extends Account {
private double interestRate;
public SavingsAccount(String accountNumber, double interestRate) {
super(accountNumber, "SAVINGS"); // ✅ Default constructor accessible
this.interestRate = interestRate;
this.currency = "USD"; // ✅ Protected variable accessible
}
public void applyInterest() {
double interest = getBalance() * interestRate / 100;
deposit(interest);
System.out.println("Interest applied: $" + interest);
}
// Can access protected method from parent
public void changeCurrency(String newCurrency) {
setCurrency(newCurrency); // ✅ Protected method accessible
System.out.println("Currency changed to: " + newCurrency);
}
}
// File 5: com/company/client/ClientApp.java
package com.company.client;
import com.company.bank.Bank;
import com.company.bank.Account;
import com.company.bank.SavingsAccount;
// import com.company.bank.BankManager; // ❌ Cannot import - default access
public class ClientApp {
public static void main(String[] args) {
System.out.println("=== CLIENT APPLICATION ===");
Bank bank = new Bank();
// Open accounts
bank.openAccount("ACC001", "CHECKING");
bank.openAccount("ACC002", "SAVINGS");
// Client can only use public interface
Account account = new SavingsAccount("ACC003", 2.5);
account.deposit(1000); // ✅ Public method
account.withdraw(200); // ✅ Public method
System.out.println("Balance: $" + account.getBalance());
// ❌ Client CANNOT access default members
// account.internalAccountUpdate("PREMIUM"); // Compilation error
// System.out.println(account.accountType); // Compilation error
// ❌ Client CANNOT access protected members directly
// account.setCurrency("EUR"); // Compilation error
// System.out.println(account.currency); // Compilation error
// ❌ Client CANNOT access default classes
// BankManager manager = new BankManager("MGR001"); // Compilation error
System.out.println("Client can only use public methods - proper encapsulation!");
}
}
Example 4: Utility Package with Default Access
// File 1: com/utils/Logger.java
package com.utils;
// Public utility class
public class Logger {
private static LogLevel currentLevel = LogLevel.INFO;
// Default access enum - internal to package
enum LogLevel {
DEBUG, INFO, WARN, ERROR
}
// Default access constructor - prevent instantiation from outside package
Logger() {
throw new AssertionError("Cannot instantiate utility class");
}
// Public static methods
public static void info(String message) {
log(LogLevel.INFO, message);
}
public static void error(String message) {
log(LogLevel.ERROR, message);
}
public static void setLevel(LogLevel level) {
currentLevel = level;
}
// Default access method - internal package use
static void debug(String message) {
if (currentLevel.ordinal() <= LogLevel.DEBUG.ordinal()) {
System.out.println("[DEBUG] " + message);
}
}
// Private method
private static void log(LogLevel level, String message) {
if (level.ordinal() >= currentLevel.ordinal()) {
System.out.println("[" + level + "] " + message);
}
}
// Default access utility method
static String formatMessage(String source, String message) {
return source + ": " + message;
}
}
// File 2: com/utils/ConfigLoader.java
package com.utils;
// Default access class - internal utility
class ConfigLoader {
private static final String CONFIG_FILE = "app.config";
// Default access constructor
ConfigLoader() {}
// Default access method
static void loadConfiguration() {
System.out.println("Loading configuration from: " + CONFIG_FILE);
Logger.debug("Configuration loading started"); // ✅ Can access default method
}
// Default access method
static String getDatabaseUrl() {
Logger.debug("Fetching database URL"); // ✅ Can access default method
return "jdbc:mysql://localhost:3306/mydb";
}
}
// File 3: com/utils/FileUtils.java
package com.utils;
// Public utility class
public class FileUtils {
// Default access constant - internal use
static final int MAX_FILE_SIZE = 1024 * 1024; // 1MB
// Private constructor
private FileUtils() {
throw new AssertionError("Cannot instantiate utility class");
}
// Public method
public static boolean isValidFile(String filename) {
return filename != null && !filename.trim().isEmpty();
}
// Default access method - internal package use
static boolean isFileTooLarge(long fileSize) {
return fileSize > MAX_FILE_SIZE;
}
// Default access method
static void logFileOperation(String operation) {
Logger.debug("File operation: " + operation); // ✅ Can access default method
}
}
// File 4: com/utils/UtilsDemo.java
package com.utils;
public class UtilsDemo {
public static void main(String[] args) {
System.out.println("=== UTILITIES PACKAGE DEMO ===");
// ✅ Can use public methods
Logger.info("Application started");
Logger.error("Something went wrong");
// ✅ Can use default methods in same package
Logger.debug("Debug message"); // ✅ Default method - same package
ConfigLoader.loadConfiguration(); // ✅ Default class and method
// ✅ Can access default members
String dbUrl = ConfigLoader.getDatabaseUrl();
System.out.println("Database URL: " + dbUrl);
// ✅ Can use default methods from FileUtils
FileUtils.logFileOperation("read"); // ✅ Default method - same package
// Test file validation
System.out.println("Valid file: " + FileUtils.isValidFile("document.pdf"));
// ❌ Cannot access private members
// Logger.currentLevel = Logger.LogLevel.DEBUG; // Compilation error
}
}
// File 5: com/application/MainApp.java
package com.application;
import com.utils.Logger;
import com.utils.FileUtils;
// import com.utils.ConfigLoader; // ❌ Cannot import - default access
// import com.utils.Logger.LogLevel; // ❌ Cannot import - default access
public class MainApp {
public static void main(String[] args) {
System.out.println("=== MAIN APPLICATION ===");
// ✅ Can use public utility methods
Logger.info("Main application started");
Logger.error("An error occurred");
// ✅ Can use public FileUtils methods
System.out.println("Valid file: " + FileUtils.isValidFile("test.txt"));
// ❌ CANNOT access default members from different package
// Logger.debug("Debug message"); // Compilation error
// Logger.setLevel(Logger.LogLevel.DEBUG); // Compilation error
// ❌ CANNOT access default classes
// ConfigLoader.loadConfiguration(); // Compilation error
// ❌ CANNOT access default methods
// FileUtils.logFileOperation("write"); // Compilation error
// System.out.println(FileUtils.MAX_FILE_SIZE); // Compilation error
System.out.println("External packages can only use public interface");
}
}
Example 5: Common Pitfalls and Best Practices
package com.pitfalls;
public class CommonPitfalls {
public static void main(String[] args) {
System.out.println("=== COMMON PITFALLS ===");
// ❌ PITFALL 1: Accidentally using default when you meant public
InternalUtility utility = new InternalUtility();
utility.internalMethod(); // Works here but not from other packages
// ❌ PITFALL 2: Assuming default access is more restrictive than it is
SamePackageClass samePkg = new SamePackageClass();
samePkg.defaultMethod(); // Accessible - might be unexpected
System.out.println("\n=== BEST PRACTICES ===");
// ✅ GOOD: Using default for package-private implementation
PackagePrivateImpl impl = new PackagePrivateImpl();
impl.doSomething();
// ✅ GOOD: Public interface with default implementation
PublicAPI api = new PublicAPI();
api.publicMethod();
}
}
// ❌ PITFALL: Class meant to be public but accidentally default
class InternalUtility { // Should probably be public if used externally
void internalMethod() {
System.out.println("This might be accidentally package-private");
}
}
// ✅ GOOD: Intentional package-private class
class PackagePrivateImpl {
// Default access - clearly intended for internal use
void doSomething() {
System.out.println("Internal implementation detail");
}
}
// ✅ GOOD: Public API with internal helpers
public class PublicAPI {
// Public method - external interface
public void publicMethod() {
internalHelper(); // Use internal implementation
System.out.println("Public method completed");
}
// Default method - internal implementation
void internalHelper() {
System.out.println("Internal helper method");
}
}
// Class to demonstrate same-package access
class SamePackageClass {
String defaultVariable = "Accessible in same package";
void defaultMethod() {
System.out.println("Default method - accessible in package");
}
}
// Another package to demonstrate access restrictions
package com.anotherpackage;
import com.pitfalls.PublicAPI;
// import com.pitfalls.InternalUtility; // ❌ Cannot import - default access
// import com.pitfalls.PackagePrivateImpl; // ❌ Cannot import - default access
public class ExternalClient {
public static void main(String[] args) {
System.out.println("=== EXTERNAL CLIENT VIEW ===");
// ✅ Can access public class and methods
PublicAPI api = new PublicAPI();
api.publicMethod();
// ❌ Cannot access default classes
// InternalUtility utility = new InternalUtility(); // Compilation error
// PackagePrivateImpl impl = new PackagePrivateImpl(); // Compilation error
// ❌ Cannot access default methods even from public class
// api.internalHelper(); // Compilation error
System.out.println("External clients see only the public interface");
}
}
When to Use Default Access Modifier
✅ Appropriate Uses:
- Package-internal classes that shouldn't be used outside
- Helper methods within a package
- Implementation details that should stay within the package
- Package-level utilities and helpers
- Classes/methods that are part of package's internal architecture
❌ Avoid When:
- The class/method is part of public API
- You want the member to be accessible from other packages
- The member should be accessible to subclasses in other packages
Best Practices
- Be intentional about using default access - don't just forget to specify public
- Use for true package-private implementation details
- Document why something is package-private if it's not obvious
- Use package structure to logically group related functionality
- Consider making utility class constructors private to prevent instantiation
- Use default for testing package-internal methods if needed
Common Patterns
// Pattern 1: Package-private implementation with public interface
public interface Service {
void publicMethod();
}
class ServiceImpl implements Service { // Default access - internal
public void publicMethod() {
internalHelper();
}
void internalHelper() { // Default access - package private
// implementation
}
}
// Pattern 2: Utility class with package-private helpers
public final class StringUtils {
private StringUtils() {}
public static boolean isBlank(String s) {
return s == null || s.trim().isEmpty();
}
static String normalizeInternal(String s) { // Default access
return s == null ? "" : s.trim().toLowerCase();
}
}
// Pattern 3: Factory with package-private products
public class ProductFactory {
public static Product createProduct() {
return new ConcreteProduct(); // ConcreteProduct has default access
}
}
class ConcreteProduct implements Product { // Default access
// implementation
}
Conclusion
The default access modifier is Java's package-level encapsulation mechanism:
- ✅ Package-private: Accessible only within the same package
- ✅ Simple: No keyword needed - the default behavior
- ✅ Encapsulation: Hides implementation details within packages
- ✅ Organization: Encourages logical package structure
Key Takeaways:
- Default access = package-private access
- Use for internal implementation within a package
- Be intentional - don't accidentally make things package-private
- Package structure matters for organizing related functionality
- Combines well with public interfaces for clean architecture
The default access modifier is a powerful tool for creating well-organized, encapsulated Java packages where internal implementation details are hidden from external users, leading to more maintainable and robust code!