When you write a class, method, or field with no access modifier at all, Java gives it default access — also called package-private. No keyword is needed and none should be added. The absence of a modifier is itself the declaration.

Default access is the middle ground between the total privacy of private and the team-wide sharing of protected. It says: this member belongs to the package as a unit. Classes within the same package can see and use it freely. Everything outside the package — regardless of whether it is a subclass, a sibling package, or a completely unrelated class — cannot.

This is the access level that makes packages feel like modules. A package can have a clean, small public surface for external callers, a set of private implementation details hidden within each class, and a layer of default members shared freely among the cooperating classes that make up the package.

The Rule — No Keyword, Package Only

DEFAULT (package-private) — written by omitting any modifier:

  class Helper { }              ← default class — visible in this package only
  int counter;                  ← default field — visible in this package only
  void process() { }            ← default method — visible in this package only

  Who can access it?

    ✓ Any class in the SAME package
    ✗ Subclasses in a DIFFERENT package
    ✗ Any non-subclass in a different package
    ✗ Even a direct subclass in a different package

  Note: Unlike protected, default does NOT extend access through inheritance.
  A subclass in a different package has NO access to default members of its parent.

  Scope comparison:
  private     → this class only
  default     → this package (same directory group)
  protected   → this package + subclasses anywhere
  public      → everywhere

1 — Default Class: Package-Internal Helper

A top-level class without public is package-private. It cannot be imported by classes in other packages. It exists to serve its package siblings — it is not part of the public API.

Java

Try it out

// File: com/devstackflow/payment/PaymentRequest.java
package com.devstackflow.payment;

// public class — visible to all packages (part of the external API)
public class PaymentRequest {

    private final String merchantId;
    private final String customerId;
    private final double amount;

    public PaymentRequest(String merchantId, String customerId, double amount) {
        this.merchantId = merchantId;
        this.customerId = customerId;
        this.amount     = amount;
    }

    public String getMerchantId() { return merchantId; }
    public String getCustomerId() { return customerId; }
    public double getAmount()     { return amount; }

    @Override
    public String toString() {
        return String.format("PaymentRequest[merchant=%s, customer=%s, Rs.%.2f]",
                merchantId, customerId, amount);
    }
}

Java

Try it out

// File: com/devstackflow/payment/PaymentValidator.java
package com.devstackflow.payment;

// NO 'public' — package-private class
// Only classes in com.devstackflow.payment can use this
class PaymentValidator {

    private static final double MIN_AMOUNT = 1.0;
    private static final double MAX_AMOUNT = 100_000.0;

    // package-private method — same package only
    boolean isValid(PaymentRequest request) {
        if (request == null) return false;
        if (!isMerchantValid(request.getMerchantId())) return false;
        if (!isAmountInRange(request.getAmount()))     return false;
        return true;
    }

    String getValidationError(PaymentRequest request) {
        if (request == null)                            return "Request is null.";
        if (!isMerchantValid(request.getMerchantId())) return "Invalid merchant ID.";
        if (!isAmountInRange(request.getAmount()))
            return String.format("Amount must be Rs.%.0f-Rs.%.0f.", MIN_AMOUNT, MAX_AMOUNT);
        return null;
    }

    // private helpers — completely internal
    private boolean isMerchantValid(String merchantId) {
        return merchantId != null && !merchantId.isBlank()
                && merchantId.startsWith("MID-");
    }

    private boolean isAmountInRange(double amount) {
        return amount >= MIN_AMOUNT && amount <= MAX_AMOUNT;
    }
}

Java

Try it out

// File: com/devstackflow/payment/PaymentLogger.java
package com.devstackflow.payment;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

// package-private — only the payment package uses this
class PaymentLogger {

    private final List<String> log = new ArrayList<>();

    void record(String status, PaymentRequest request) {
        String entry = String.format("[%s] %s | %s",
                LocalDateTime.now().toLocalTime().withNano(0),
                status, request);
        log.add(entry);
        System.out.println("  LOG: " + entry);
    }

    List<String> getLog() {
        return List.copyOf(log);
    }
}

Java

Try it out

// File: com/devstackflow/payment/PaymentService.java
package com.devstackflow.payment;

// public class — this is the external-facing API
public class PaymentService {

    // Package-private helpers — used freely within the package
    private final PaymentValidator validator = new PaymentValidator();
    private final PaymentLogger    logger    = new PaymentLogger();

    public String process(PaymentRequest request) {

        String error = validator.getValidationError(request); // package-private method
        if (error != null) {
            logger.record("REJECTED", request);               // package-private method
            return "REJECTED: " + error;
        }

        // Simulate processing
        String txnId = "TXN-" + System.currentTimeMillis();
        logger.record("APPROVED", request);
        return "APPROVED: " + txnId;
    }

    public List<String> getAuditLog() {
        return logger.getLog();  // package-private method
    }
}

Java

Try it out

// File: com/devstackflow/demo/PaymentDemo.java
package com.devstackflow.demo;

import com.devstackflow.payment.PaymentRequest;
import com.devstackflow.payment.PaymentService;
// import com.devstackflow.payment.PaymentValidator; ← compile error — package-private class
// import com.devstackflow.payment.PaymentLogger;    ← compile error — package-private class

public class PaymentDemo {

    public static void main(String[] args) {

        PaymentService service = new PaymentService();  // public class — OK

        PaymentRequest[] requests = {
            new PaymentRequest("MID-001", "CUST-501", 2499.0),
            new PaymentRequest("",         "CUST-502", 500.0),   // invalid merchant
            new PaymentRequest("MID-002", "CUST-503", -100.0),   // invalid amount
            new PaymentRequest("MID-003", "CUST-504", 75000.0),
        };

        System.out.println("╔══════════════════════════════════════════╗");
        System.out.println("║    PAYMENT SERVICE DEMO                 ║");
        System.out.println("╚══════════════════════════════════════════╝\n");

        for (PaymentRequest req : requests) {
            System.out.println("Request : " + req);
            System.out.println("Result  : " + service.process(req));
            System.out.println();
        }

        System.out.println("=== Audit Log ===");
        service.getAuditLog().forEach(System.out::println);

        // PaymentValidator v = new PaymentValidator(); ← compile error
        // PaymentLogger l    = new PaymentLogger();    ← compile error
        // service.validator  ← compile error — private field
    }
}

Output:
╔══════════════════════════════════════════╗
║    PAYMENT SERVICE DEMO                 ║
╚══════════════════════════════════════════╝

Request : PaymentRequest[merchant=MID-001, customer=CUST-501, Rs.2499.00]
  LOG: [10:30:00] APPROVED | PaymentRequest[merchant=MID-001, customer=CUST-501, Rs.2499.00]
Result  : APPROVED: TXN-1705312200000

Request : PaymentRequest[merchant=, customer=CUST-502, Rs.500.00]
  LOG: [10:30:00] REJECTED | PaymentRequest[merchant=, customer=CUST-502, Rs.500.00]
Result  : REJECTED: Invalid merchant ID.

Request : PaymentRequest[merchant=MID-002, customer=CUST-503, Rs.-100.00]
  LOG: [10:30:00] REJECTED | PaymentRequest[merchant=MID-002, customer=CUST-503, Rs.-100.00]
Result  : REJECTED: Amount must be Rs.1-Rs.100000.

Request : PaymentRequest[merchant=MID-003, customer=CUST-504, Rs.75000.00]
  LOG: [10:30:00] APPROVED | PaymentRequest[merchant=MID-003, customer=CUST-504, Rs.75000.00]
Result  : APPROVED: TXN-1705312200003

=== Audit Log ===
[10:30:00] APPROVED | PaymentRequest[merchant=MID-001, customer=CUST-501, Rs.2499.00]
[10:30:00] REJECTED | PaymentRequest[merchant=, customer=CUST-502, Rs.500.00]
[10:30:00] REJECTED | PaymentRequest[merchant=MID-002, customer=CUST-503, Rs.-100.00]
[10:30:00] APPROVED | PaymentRequest[merchant=MID-003, customer=CUST-504, Rs.75000.00]

PaymentValidator and PaymentLogger are completely invisible outside the package. PaymentService — the only public class — orchestrates them internally. External callers see exactly one class and two methods. The package is a self-contained module.

2 — Default Fields and Methods: Package-Level Sharing

Default fields and methods let classes within a package share data and behaviour without wrapping everything in getters and setters — trusting the package as a controlled, cohesive unit.

Java

Try it out

// File: com/devstackflow/cache/CacheEntry.java
package com.devstackflow.cache;

import java.time.LocalDateTime;

class CacheEntry {     // package-private class

    // package-private fields — trusted within the package
    String key;
    Object value;
    LocalDateTime createdAt;
    LocalDateTime expiresAt;
    int           hitCount;

    CacheEntry(String key, Object value, int ttlSeconds) {
        this.key       = key;
        this.value     = value;
        this.createdAt = LocalDateTime.now();
        this.expiresAt = createdAt.plusSeconds(ttlSeconds);
        this.hitCount  = 0;
    }

    // package-private methods
    boolean isExpired() {
        return LocalDateTime.now().isAfter(expiresAt);
    }

    void recordHit() {
        hitCount++;
    }

    @Override
    public String toString() {
        return String.format("CacheEntry{key=%s, hits=%d, expired=%s}",
                key, hitCount, isExpired());
    }
}

Java

Try it out

// File: com/devstackflow/cache/CacheStats.java
package com.devstackflow.cache;

// package-private — internal statistics tracker
class CacheStats {

    int totalPuts  = 0;  // package-private fields
    int totalHits  = 0;
    int totalMisses = 0;
    int totalEvictions = 0;

    void recordPut()      { totalPuts++;       }
    void recordHit()      { totalHits++;       }
    void recordMiss()     { totalMisses++;     }
    void recordEviction() { totalEvictions++;  }

    double hitRate() {
        int total = totalHits + totalMisses;
        return total == 0 ? 0.0 : (totalHits * 100.0) / total;
    }

    @Override
    public String toString() {
        return String.format(
                "CacheStats{puts=%d, hits=%d, misses=%d, evictions=%d, hitRate=%.1f%%}",
                totalPuts, totalHits, totalMisses, totalEvictions, hitRate());
    }
}

Java

Try it out

// File: com/devstackflow/cache/LocalCache.java
package com.devstackflow.cache;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class LocalCache {

    // private — the actual data; not even package siblings touch it directly
    private final Map<String, CacheEntry> store   = new HashMap<>();
    private final CacheStats              stats   = new CacheStats();
    private final int                     maxSize;
    private final int                     defaultTtl;

    public LocalCache(int maxSize, int defaultTtlSeconds) {
        this.maxSize    = maxSize;
        this.defaultTtl = defaultTtlSeconds;
    }

    public void put(String key, Object value) {
        if (store.size() >= maxSize) {
            evictOldest();  // private
        }
        store.put(key, new CacheEntry(key, value, defaultTtl));
        stats.recordPut();   // package-private field and method
    }

    public Optional<Object> get(String key) {
        CacheEntry entry = store.get(key);
        if (entry == null) {
            stats.recordMiss();
            return Optional.empty();
        }
        if (entry.isExpired()) {    // package-private method
            store.remove(key);
            stats.recordEviction();
            return Optional.empty();
        }
        entry.recordHit();          // package-private method
        stats.recordHit();
        return Optional.of(entry.value);  // package-private field
    }

    public void remove(String key) {
        if (store.remove(key) != null) {
            stats.recordEviction();
        }
    }

    public String getStats() {
        return stats.toString();  // package-private class method
    }

    public int size() { return store.size(); }

    private void evictOldest() {
        store.keySet().stream().findFirst()
                .ifPresent(k -> {
                    store.remove(k);
                    stats.recordEviction();
                });
    }
}

Java

Try it out

// File: com/devstackflow/demo/CacheDemo.java
package com.devstackflow.demo;

import com.devstackflow.cache.LocalCache;

public class CacheDemo {

    public static void main(String[] args) throws InterruptedException {

        LocalCache cache = new LocalCache(5, 3); // max 5 entries, 3 sec TTL

        cache.put("user:101", "Priya Sharma");
        cache.put("user:102", "Rohan Mehta");
        cache.put("prod:001", "Laptop");

        System.out.println("Get user:101 : " + cache.get("user:101").orElse("MISS"));
        System.out.println("Get user:102 : " + cache.get("user:102").orElse("MISS"));
        System.out.println("Get user:999 : " + cache.get("user:999").orElse("MISS"));
        System.out.println("Get user:101 : " + cache.get("user:101").orElse("MISS")); // hit again
        System.out.println("Cache size   : " + cache.size());
        System.out.println("Stats        : " + cache.getStats());

        // CacheEntry and CacheStats are invisible here:
        // new CacheEntry(...) ← compile error — package-private class
        // new CacheStats()    ← compile error — package-private class
        // cache.stats         ← compile error — private field (CacheStats itself package-private)
    }
}

Output:
Get user:101 : Priya Sharma
Get user:102 : Rohan Mehta
Get user:999 : MISS
Get user:101 : Priya Sharma
Cache size   : 3
Stats        : CacheStats{puts=3, hits=3, misses=1, evictions=0, hitRate=75.0%}

CacheEntry and CacheStats are package-private. LocalCache uses them directly — accessing fields like entry.hitCount, entry.value, and stats.totalHits without getters. The package trusts its own members. External callers only see LocalCache with its clean public interface.

3 — Default vs Inheritance: The Key Difference From protected

Default access does NOT extend through inheritance to subclasses in other packages. This is the most important distinction between default and protected.

Java

Try it out

// File: com/devstackflow/base/Template.java
package com.devstackflow.base;

public class Template {

    String defaultField   = "default";    // package-private
    protected String prot = "protected"; // protected
    public    String pub  = "public";    // public

    void defaultMethod()   { System.out.println("default method in Template"); }
    protected void protMethod() { System.out.println("protected method in Template"); }
    public    void pubMethod()  { System.out.println("public method in Template"); }
}

Java

Try it out

// File: com/devstackflow/child/ChildClass.java
package com.devstackflow.child;   // DIFFERENT package

import com.devstackflow.base.Template;

public class ChildClass extends Template {

    public void demonstrate() {

        // public — always accessible
        System.out.println("public field : " + pub);
        pubMethod();

        // protected — accessible through inheritance in subclass
        System.out.println("protected    : " + prot);
        protMethod();

        // default — NOT accessible from different package, even in subclass
        // System.out.println(defaultField); ← compile error
        // defaultMethod();                  ← compile error
        // Default access does NOT cross package boundaries via inheritance

        System.out.println("Default members — NOT accessible from different package.");
    }
}

Java

Try it out

// File: com/devstackflow/demo/InheritanceDefaultDemo.java
package com.devstackflow.demo;

import com.devstackflow.child.ChildClass;

public class InheritanceDefaultDemo {

    public static void main(String[] args) {

        ChildClass child = new ChildClass();
        child.demonstrate();

        // From completely outside — only public accessible
        System.out.println("\nFrom non-subclass:");
        System.out.println("public       : " + child.pub);
        child.pubMethod();
        // child.prot            ← compile error — protected, not subclass
        // child.defaultField    ← compile error — default, different package
    }
}

Output:
public field : public
public method in Template
protected    : protected
protected method in Template
Default members — NOT accessible from different package.

From non-subclass:
public       : public
public method in Template

All Four Access Modifiers — Complete Comparison Table

Aspect	`private`	`default`	`protected`	`public`
Same class	✓	✓	✓	✓
Same package — different class	✗	✓	✓	✓
Subclass in same package	✗	✓	✓	✓
Subclass in different package	✗	✗	✓	✓
Non-subclass in different package	✗	✗	✗	✓
Access via inheritance (cross-package)	✗	✗	✓	✓
Valid on top-level class	✗	✓	✗	✓
Valid on members	✓	✓	✓	✓
Keyword required	`private`	none	`protected`	`public`
Primary use	Class internals	Package module	Extensibility hooks	External API
Intended audience	This class only	Package team	Subclass authors	All callers
Risk if overused	Under-sharing	Tight package coupling	Fragile inheritance	Broken encapsulation

The Package as a Module — Designing With default

The most powerful use of default access is designing a package as a self-contained module with a minimal public surface.

Package as a module — com.myapp.order:

  External API (public):               Internal implementation (default):
  ─────────────────────────────        ──────────────────────────────────
  public OrderService                  class OrderRepository
  public OrderRequest                  class OrderValidator
  public OrderResponse                 class OrderMapper
  public OrderNotFoundException        class OrderIdGenerator
                                       class OrderAuditLogger

  External callers see and use          Package classes share freely
  only the public surface.              among themselves.

  Changing the internal classes         Changing the public surface
  never breaks external callers.        requires updating all callers.

  The default classes are free          The public classes are a
  to be refactored, renamed,            commitment that callers
  split, or merged at any time.         depend on.

Real-World Example — Order Processing Module

The Business Problem

An order processing module at a platform like Meesho has multiple internal classes — a mapper that converts request data, a repository that simulates database access, an ID generator, and a validator. Only OrderService and the data model classes are public. The rest are package-private implementation details that can evolve freely without affecting any external caller.

Java

Try it out

// File: com/meesho/order/model/OrderRequest.java
package com.meesho.order.model;

public class OrderRequest {      // public — external teams create these
    private final String customerId;
    private final String productId;
    private final int    quantity;
    private final double unitPrice;

    public OrderRequest(String customerId, String productId,
                         int quantity, double unitPrice) {
        this.customerId = customerId;
        this.productId  = productId;
        this.quantity   = quantity;
        this.unitPrice  = unitPrice;
    }

    public String getCustomerId() { return customerId; }
    public String getProductId()  { return productId; }
    public int    getQuantity()   { return quantity; }
    public double getUnitPrice()  { return unitPrice; }
    public double getTotalAmount(){ return unitPrice * quantity; }
}

Java

Try it out

// File: com/meesho/order/model/OrderRecord.java
package com.meesho.order.model;

import java.time.LocalDateTime;

public class OrderRecord {       // public — callers receive these
    public final String        orderId;
    public final String        customerId;
    public final String        productId;
    public final double        totalAmount;
    public final String        status;
    public final LocalDateTime createdAt;

    // package-private constructor — only order package creates OrderRecord
    OrderRecord(String orderId, String customerId, String productId,
                double totalAmount, String status) {
        this.orderId      = orderId;
        this.customerId   = customerId;
        this.productId    = productId;
        this.totalAmount  = totalAmount;
        this.status       = status;
        this.createdAt    = LocalDateTime.now();
    }

    @Override
    public String toString() {
        return String.format("[%s] %s | product=%s | Rs.%.2f | %s",
                orderId, customerId, productId, totalAmount, status);
    }
}

Java

Try it out

// File: com/meesho/order/OrderIdGenerator.java
package com.meesho.order;

import java.util.concurrent.atomic.AtomicInteger;

// package-private — only the order package generates IDs
class OrderIdGenerator {
    private static final AtomicInteger counter = new AtomicInteger(1000);

    static String generate() {
        return "MSH-ORD-" + String.format("%06d", counter.getAndIncrement());
    }
}

Java

Try it out

// File: com/meesho/order/OrderValidator.java
package com.meesho.order;

import com.meesho.order.model.OrderRequest;

// package-private — validation is an internal concern
class OrderValidator {

    private static final int    MAX_QUANTITY = 50;
    private static final double MAX_AMOUNT   = 50_000.0;

    ValidationResult validate(OrderRequest request) {
        if (request == null)
            return ValidationResult.fail("Request cannot be null.");
        if (request.getCustomerId() == null || request.getCustomerId().isBlank())
            return ValidationResult.fail("Customer ID is required.");
        if (request.getProductId() == null || request.getProductId().isBlank())
            return ValidationResult.fail("Product ID is required.");
        if (request.getQuantity() <= 0 || request.getQuantity() > MAX_QUANTITY)
            return ValidationResult.fail("Quantity must be 1-" + MAX_QUANTITY + ".");
        if (request.getTotalAmount() > MAX_AMOUNT)
            return ValidationResult.fail("Order total exceeds limit of Rs." + MAX_AMOUNT + ".");
        return ValidationResult.ok();
    }
}

Java

Try it out

// File: com/meesho/order/ValidationResult.java
package com.meesho.order;

// package-private — internal result type
class ValidationResult {
    final boolean valid;
    final String  error;

    private ValidationResult(boolean valid, String error) {
        this.valid = valid;
        this.error = error;
    }

    static ValidationResult ok()           { return new ValidationResult(true,  null);  }
    static ValidationResult fail(String e) { return new ValidationResult(false, e);     }
}

Java

Try it out

// File: com/meesho/order/OrderRepository.java
package com.meesho.order;

import com.meesho.order.model.OrderRecord;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

// package-private — data access is an internal concern
class OrderRepository {

    private final List<OrderRecord> store = new ArrayList<>();

    void save(OrderRecord record) {
        store.add(record);
    }

    Optional<OrderRecord> findById(String orderId) {
        return store.stream()
                .filter(r -> r.orderId.equals(orderId))
                .findFirst();
    }

    List<OrderRecord> findByCustomer(String customerId) {
        return store.stream()
                .filter(r -> r.customerId.equals(customerId))
                .collect(java.util.stream.Collectors.toList());
    }

    int count() { return store.size(); }
}

Java

Try it out

// File: com/meesho/order/OrderService.java
package com.meesho.order;

import com.meesho.order.model.OrderRecord;
import com.meesho.order.model.OrderRequest;

import java.util.List;
import java.util.Optional;

// public — this is the only entry point for external callers
public class OrderService {

    // Package-private helpers — freely instantiated within the package
    private final OrderValidator   validator  = new OrderValidator();
    private final OrderRepository  repository = new OrderRepository();

    public OrderRecord placeOrder(OrderRequest request) {
        ValidationResult result = validator.validate(request);   // default class
        if (!result.valid) {                                      // default field
            throw new IllegalArgumentException(result.error);    // default field
        }

        String orderId = OrderIdGenerator.generate();            // default static method
        OrderRecord record = new OrderRecord(                    // default constructor
                orderId,
                request.getCustomerId(),
                request.getProductId(),
                request.getTotalAmount(),
                "PLACED");

        repository.save(record);                                 // default method
        return record;
    }

    public Optional<OrderRecord> getOrder(String orderId) {
        return repository.findById(orderId);
    }

    public List<OrderRecord> getCustomerOrders(String customerId) {
        return repository.findByCustomer(customerId);
    }

    public int getTotalOrders() {
        return repository.count();
    }
}

Java

Try it out

// File: com/meesho/OrderApp.java
package com.meesho;

import com.meesho.order.OrderService;
import com.meesho.order.model.OrderRecord;
import com.meesho.order.model.OrderRequest;

public class OrderApp {

    public static void main(String[] args) {

        System.out.println("╔══════════════════════════════════════════╗");
        System.out.println("║      MEESHO ORDER MODULE DEMO           ║");
        System.out.println("╚══════════════════════════════════════════╝\n");

        OrderService service = new OrderService();

        // Place orders
        System.out.println("=== Placing Orders ===");
        OrderRecord r1 = service.placeOrder(
                new OrderRequest("CUST-101", "PROD-A", 2, 699.0));
        OrderRecord r2 = service.placeOrder(
                new OrderRequest("CUST-102", "PROD-B", 1, 1299.0));
        OrderRecord r3 = service.placeOrder(
                new OrderRequest("CUST-101", "PROD-C", 3, 499.0));

        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);

        // Query orders
        System.out.println("\n=== Orders for CUST-101 ===");
        service.getCustomerOrders("CUST-101")
               .forEach(System.out::println);

        System.out.println("\n=== Get by ID ===");
        service.getOrder(r2.orderId)
               .ifPresent(System.out::println);

        System.out.println("\nTotal orders: " + service.getTotalOrders());

        // Validation failure
        System.out.println("\n=== Validation Failure ===");
        try {
            service.placeOrder(new OrderRequest("", "PROD-D", 1, 299.0));
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }

        // These are invisible from outside the package:
        // new OrderValidator()    ← compile error — package-private class
        // new OrderRepository()   ← compile error — package-private class
        // new OrderIdGenerator()  ← compile error — package-private class
        // OrderIdGenerator.generate() ← compile error — package-private class
        // new OrderRecord(...)    ← compile error — package-private constructor
    }
}

Output:
╔══════════════════════════════════════════╗
║      MEESHO ORDER MODULE DEMO           ║
╚══════════════════════════════════════════╝

=== Placing Orders ===
[MSH-ORD-001000] CUST-101 | product=PROD-A | Rs.1398.00 | PLACED
[MSH-ORD-001001] CUST-102 | product=PROD-B | Rs.1299.00 | PLACED
[MSH-ORD-001002] CUST-101 | product=PROD-C | Rs.1497.00 | PLACED

=== Orders for CUST-101 ===
[MSH-ORD-001000] CUST-101 | product=PROD-A | Rs.1398.00 | PLACED
[MSH-ORD-001002] CUST-101 | product=PROD-C | Rs.1497.00 | PLACED

=== Get by ID ===
[MSH-ORD-001001] CUST-102 | product=PROD-B | Rs.1299.00 | PLACED

Total orders: 3

=== Validation Failure ===
Error: Customer ID is required.

Six classes in the package — only OrderService, OrderRequest, and OrderRecord are public. OrderValidator, OrderRepository, OrderIdGenerator, ValidationResult, and the OrderRecord constructor are all package-private. External callers in com.meesho can see and use exactly what they need. The internal implementation is completely sealed.

Best Practices

Use default access intentionally, not by accident. Omitting a modifier is a deliberate design choice — it means "this belongs to the package". Write a conscious comment or follow a team convention that distinguishes intentional package-private from "I forgot to write public". Some teams prefix package-private classes with a comment /* package */ to make the intent explicit.

Design packages as cohesive modules with a small public surface. A well-designed package exposes a handful of public classes as its API. Everything else is default — internal validators, mappers, repositories, ID generators, result types. This modularity means the internal implementation can be refactored freely without any impact on callers.

Prefer default over protected for internal helpers that subclasses do not need. protected leaks members into the subclass space — every subclass author in any package can see and depend on them. If a helper method or class is only needed within the package and no subclass in a different package has a genuine need for it, keep it default. Reserve protected for intentional extensibility hooks.

Avoid putting unrelated classes in the same package just for default access. Default access is not a reason to create a sprawling package. If two groups of classes have default access to each other but conceptually belong to different layers or domains, they should be in separate packages with a cleaner, controlled interface between them.

Common Mistakes

Mistake 1 — Accidentally Making a Class Package-Private

Java

Try it out

// WRONG — forgot public; this class is package-private unintentionally
class UserController {           // only visible in this package
    public void handleLogin() { }
}

// This causes a cascade: any class in another package cannot import it,
// Spring cannot inject it as a bean, APIs cannot map to it, etc.

// Fix — add public if it is meant for external use
public class UserController {
    public void handleLogin() { }
}

Mistake 2 — Expecting Default to Cross Package Boundaries

Java

Try it out

// com.myapp.base.Base
package com.myapp.base;
public class Base {
    void helper() { System.out.println("base helper"); }  // default
}

// com.myapp.child.Child
package com.myapp.child;
import com.myapp.base.Base;

public class Child extends Base {
    public void go() {
        helper();  // compile error — default does not cross packages, even with inheritance
    }
}

// Fix — make helper() protected if Child genuinely needs it
// OR restructure so Child is in the same package as Base

Mistake 3 — Using the Same Package to Avoid Defining Proper Interfaces

Java

Try it out

// WRONG — shoving unrelated classes into one package so they share default access
package com.myapp.everything;  // UserService, ProductService, PaymentService, Inventory...
// These are logically separate but all crammed together for default access

// CORRECT — define interfaces between packages; keep packages cohesive
// com.myapp.user     → UserService (public), UserRepository (default)
// com.myapp.product  → ProductService (public), ProductRepository (default)
// Each package is a cohesive unit, not a dumping ground

Mistake 4 — Testing Package-Private Classes From a Different Package

Java

Try it out

// Test class in wrong package:
package com.test;
import com.myapp.order.OrderValidator;  // compile error — package-private

// Fix 1 — put test in the SAME package
package com.myapp.order;               // same package — can access default members
// But: most test conventions put tests in a separate source root; same package name is fine

// Fix 2 — test through the public API (preferred approach)
package com.test;
import com.myapp.order.OrderService;   // public — test via public service
// OrderService internally uses OrderValidator — if it works, the validator works

Interview Questions

Q1. What is default (package-private) access in Java and how do you declare it?

Default access is the access level applied when no modifier keyword is written. It is declared by the absence of public, private, or protected. A class, field, method, or constructor with default access is visible to all classes within the same package and invisible to everything outside the package — including subclasses in different packages. The common name is "package-private" because the package is the boundary of its visibility.

Q2. What is the difference between default and protected access?

Within the same package, both default and protected provide identical access — all classes in the package can use the member. The difference is inheritance across packages: protected extends access to subclasses in any package; default does not. A subclass in a different package cannot access a default member of its parent class, even through super or this. default is strictly package-scoped; protected adds the subclass cross-package dimension.

Q3. Can a subclass in a different package inherit and access default members of its parent?

No. Default access does not cross package boundaries even through inheritance. A subclass in a different package cannot see default fields, call default methods, or override default methods of the parent. Attempting to do so causes a compile error. This is the key difference from protected, which does cross package boundaries specifically for subclasses. For a member to be accessible to subclasses in other packages, it must be protected or public.

Q4. Why is default access useful if you can just use private for everything?

private restricts access to one class. When multiple cooperating classes within a package need to share data or behaviour — a service and its validator, a processor and its mapper, a repository and its result type — private forces every interaction to go through public getters and setters, adding unnecessary boilerplate. Default access trusts the package as a cohesive unit. Classes within the same package can share fields and methods directly, without the overhead of a public API. This is how packages act as internal modules.

Q5. Is it a problem to leave the access modifier off by accident?

Yes. Accidentally omitting public from a class that is meant to be part of the external API makes it package-private — invisible and unimportable from other packages. This causes compile errors for callers, breaks Spring and Hibernate bean scanning (which cannot instantiate package-private classes), and produces subtle test failures when tests are in a different package. Always be intentional about access modifiers. If a class is meant for external use, write public explicitly. If it is an internal helper, omit the modifier deliberately and — optionally — add a comment to signal the intent.

Q6. Can default access members be tested in JUnit?

Yes, with the right package structure. JUnit test classes in the same package as the class under test have full access to default members — fields, methods, and constructors. Maven and Gradle's standard layout places test source files in src/test/java but preserves the same package name. A test class com.myapp.order.OrderValidatorTest in src/test/java has access to class OrderValidator in src/main/java/com/myapp/order/ because both share the com.myapp.order package on the classpath. This is the standard approach for testing package-private implementation classes directly.

FAQs

Is there a way to explicitly write the "default" keyword in Java?

No. Default access has no keyword. It is declared by the complete absence of any access modifier. Some teams use a comment /* package */ before the class or member to signal intentional package-private choice — /* package */ class OrderValidator { } — but this is a convention, not a language feature.

Can a package-private class implement a public interface?

Yes. A package-private class can implement any public interface. The implementing class is invisible outside the package, but objects of that class can be returned as the interface type from a public factory method. This is a powerful pattern: the interface is public, the implementation is package-private. External callers only know the interface — they cannot instantiate or cast to the implementation directly.

Does default access apply to constructors separately from the class?

Yes. A public class can have a package-private constructor — public class Foo { Foo() {} }. The class is importable from anywhere, but only code in the same package can call new Foo(). External callers are forced to use a public factory method or builder. OrderRecord in the real-world example used exactly this pattern — public class with a package-private constructor, so only the order package can create instances.

Are there any frameworks that depend on package-private access specifically?

Yes. Several Java testing libraries use package-private access for their internal structure. The Java module system relies heavily on the concept of not exporting packages — unexported packages are effectively package-private to external modules. OSGi bundles use package-private visibility as a module boundary. JPA (Hibernate) entity classes often use package-private constructors for the framework while providing public constructors for application code.

What happens to default access when using the Java module system (Java 9+)?

The Java module system (module-info.java) adds a layer above packages. Even public classes in a module are inaccessible to other modules if the package is not listed in an exports directive. Default access still works within the module as always — package-private classes are visible within their package. The module system's encapsulation is stronger than package access: it prevents reflection-based access to non-exported packages by default. Default access within a module is unchanged; it is the cross-module visibility that modules restrict.

Summary

Default (package-private) access is Java's mechanism for package-level modularity. Members with no modifier are visible to all classes within the same package and invisible to everything outside — including subclasses in other packages, which distinguishes it from protected.

Its power lies in enabling the package-as-module pattern: a small public surface for external callers, a rich set of default helpers that cooperate freely within the package, and no leakage of implementation details to the outside world. The internal classes — validators, mappers, repositories, ID generators, result types — are free to change, refactor, or be replaced entirely. Callers are insulated because they only ever depended on the public surface.

The discipline: be intentional. Write public when something is meant for external use. Write private when it belongs to one class. Omit the modifier deliberately when it should be shared within the package. Never leave it off by accident on something that should be public.

What to Read Next

Continue Learning Packages & Access Control

Next Step

Inner Classes

Learn how to define a class inside another class.

→

Access Modifiers

Learn how to control who can access your code.

→

protected Access Modifier

Learn how the protected modifier works across packages and subclasses.

→

Creating Custom Packages

Learn how to create your own package.

→

←

Previousprotected Access Modifier

NextInner Classes

→