Default access modifier in Java - Deep Dive

Overview - Default access modifier

What is it?

In Java, the default access modifier is the level of access given to classes, methods, or variables when no explicit access modifier is specified. It means that the element is accessible only within the same package. This is different from public, private, or protected modifiers, which control access more strictly or broadly. The default access helps organize code by limiting visibility to related classes.

Why it matters

Without the default access modifier, every class member would either be too exposed or too hidden, making it hard to manage code safely and clearly. It solves the problem of controlling access without extra keywords, helping developers keep parts of their code private to a package but still accessible to related classes. Without it, Java programs would be harder to maintain and more prone to accidental misuse.

Where it fits

Before learning about the default access modifier, you should understand Java classes, methods, variables, and the concept of access modifiers like public and private. After this, you can learn about protected access and advanced encapsulation techniques like modules and packages.

Mental Model

Core Idea

The default access modifier means 'package-private'—accessible only to classes in the same package, no keyword needed.

Think of it like...

It's like a neighborhood where only residents can enter each other's houses, but outsiders cannot. No special sign is needed to show this rule; it's just how the neighborhood works.

┌───────────────┐
│   Package     │
│ ┌───────────┐ │
│ │ Class A   │ │
│ │ - default │ │
│ │ access    │ │
│ └───────────┘ │
│ ┌───────────┐ │
│ │ Class B   │ │
│ │ can access│ │
│ │ Class A's │ │
│ │ default   │ │
│ │ members  │ │
│ └───────────┘ │
└───────────────┘
Outside this box, no access.

Build-Up - 6 Steps

1

Foundation

Understanding Java Access Modifiers

Concept: Java uses access modifiers to control who can see or use classes and their members.

Java has four main access levels: public (anyone can access), private (only the class itself), protected (same package and subclasses), and default (no keyword, same package only). When you don't write any modifier, Java uses default access.

Result

You know that default access means no keyword is written, and it limits access to the same package.

Understanding that Java has different access levels helps you control visibility and protect your code from unintended use.

2

Foundation

What Default Access Means in Practice

Concept: Default access restricts visibility to classes within the same package.

If you declare a class, method, or variable without any access modifier, it is accessible only to other classes in the same package. For example, a method without public, private, or protected is package-private.

Result

You can access default members from classes in the same package but not from classes in other packages.

Knowing that default access limits scope to the package helps you organize code logically and safely.

3

Intermediate

Default Access vs Other Modifiers

🤔Before reading on: do you think default access is more or less restrictive than protected? Commit to your answer.

Concept: Default access is more restrictive than protected but less restrictive than private.

Protected allows access to subclasses even outside the package, but default does not. Private restricts access to the class itself. Public allows access from anywhere. Default access is a middle ground, useful for package-level encapsulation.

Result

You can distinguish when to use default access versus protected or private based on who should access the member.

Understanding the subtle differences between access levels prevents accidental exposure or hiding of code.

4

Intermediate

How Packages Affect Default Access

🤔Before reading on: can classes in different packages access default members? Commit to yes or no.

Concept: Packages group related classes, and default access restricts visibility to within these groups.

Java uses packages as folders to organize classes. Default access means only classes in the same package folder can see each other's default members. Classes outside cannot access them, even if they import the package.

Result

You understand that package structure directly controls default access visibility.

Knowing that default access depends on package grouping helps you design your project structure for proper encapsulation.

5

Advanced

Default Access and Class Members

🤔Before reading on: do you think default access applies to constructors as well? Commit to yes or no.

Concept: Default access applies to all class members including constructors, methods, and variables.

If a constructor has default access, only classes in the same package can create instances. This can control object creation tightly within a package. Similarly, default methods and variables are hidden from outside packages.

Result

You can control object creation and member usage at the package level using default access.

Understanding that constructors can have default access unlocks powerful design patterns like package-level factories.

6

Expert

Surprising Effects of Default Access in Inheritance

🤔Before reading on: can a subclass in a different package access default members of its superclass? Commit to yes or no.

Concept: Default members are NOT accessible to subclasses outside the package, unlike protected members.

Even if a class extends another, if the superclass member has default access, the subclass outside the package cannot see it. This can cause confusion when expecting inheritance to grant access.

Result

You avoid bugs where subclass code fails to access expected members due to default access restrictions.

Knowing this prevents common mistakes in designing class hierarchies and access control.

Under the Hood

Java's compiler and runtime use the package name as a key to enforce default access. When code tries to access a member, the JVM checks if the accessing class is in the same package as the member's class. If yes, access is allowed; if not, access is denied. This check happens at compile time and runtime, ensuring encapsulation.

Why designed this way?

Default access was designed to provide a simple, implicit way to group related classes and allow them to share code without exposing it publicly. It avoids cluttering code with keywords when package-level access is desired. Alternatives like always requiring explicit modifiers would be verbose and error-prone.

┌───────────────┐
│   Class A     │
│ ┌───────────┐ │
│ │ default   │ │
│ │ member    │ │
│ └───────────┘ │
└─────┬─────────┘
      │ Access allowed if
      │ same package
┌─────▼─────────┐
│   Class B     │
│ (same package)│
└───────────────┘

Access denied if different package:

┌───────────────┐     ┌───────────────┐
│   Class A     │     │   Class C     │
│ default member│     │ (diff package)│
└───────────────┘     └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does default access mean the member is accessible from any subclass anywhere? Commit to yes or no.

Common Belief: Default access allows subclasses in any package to access the member.

Reality: Default access restricts access to the same package only; subclasses outside the package cannot access default members.

Why it matters: Assuming default access allows subclass access can cause runtime errors and broken inheritance designs.

Quick: Is default access the same as private access? Commit to yes or no.

Common Belief: Default access is just like private, hiding members from all other classes.

Reality: Default access allows access to all classes in the same package, unlike private which restricts to the declaring class only.

Why it matters: Confusing default with private can lead to overly restrictive or broken code sharing within packages.

Quick: If no access modifier is written, does Java treat the member as public? Commit to yes or no.

Common Belief: No modifier means public access by default.

Reality: No modifier means default (package-private) access, not public.

Why it matters: Assuming no modifier means public can expose code unintentionally or cause access errors.

Quick: Can classes in different packages access default members if they import the package? Commit to yes or no.

Common Belief: Importing a package allows access to default members.

Reality: Importing only allows naming classes; it does not grant access to default members outside the package.

Why it matters: Misunderstanding imports can cause confusion about visibility and lead to compilation errors.

Expert Zone

1

Default access is often overlooked but is crucial for designing package-level APIs that hide implementation details while allowing collaboration.

2

The JVM enforces default access at runtime, so even reflection respects package boundaries unless explicitly overridden.

3

Combining default access with package-private helper classes can reduce the public API surface and improve maintainability.

When NOT to use

Default access is not suitable when you need to expose members to subclasses in other packages or to the entire application. In those cases, use protected or public. For strict encapsulation within a class, use private instead.

Production Patterns

In large Java projects, default access is used to create internal packages where classes share utilities and helpers without exposing them publicly. Frameworks often use default access for internal APIs to prevent misuse by external code.

Connections

Encapsulation

Default access is a form of encapsulation controlling visibility within a package.

Understanding default access deepens your grasp of encapsulation by showing how visibility can be controlled at different levels, not just public/private.

Namespaces in other languages

Default access in Java is similar to how namespaces or modules limit visibility in languages like C# or Python.

Knowing default access helps understand how different languages organize and protect code using grouping mechanisms.

Social groups in sociology

Default access is like social group boundaries where only members share information freely.

This connection shows how access control in programming mirrors real-world social structures that balance openness and privacy.

Common Pitfalls

#1 Trying to access a default member from a class in a different package.

Wrong approach:

package other;

import mypackage.MyClass;

public class OtherClass {
public void test() {
MyClass obj = new MyClass();
obj.defaultMethod(); // Error: not visible
}
}

Correct approach:

package other;

import mypackage.MyClass;

public class OtherClass {
public void test() {
MyClass obj = new MyClass();
// Cannot call defaultMethod() because it's package-private
// Use a public method instead
obj.publicMethod();
}
}

Root cause:

Misunderstanding that default access restricts visibility to the same package only.

#2 Assuming default access is the same as private and expecting no access from other classes in the same package.

Wrong approach:

package mypackage;

class MyClass {
int defaultVar = 5; // default access
}

class OtherClass {
void test() {
MyClass obj = new MyClass();
int x = obj.defaultVar; // Allowed, but learner expects error
}
}

Correct approach:

package mypackage;

class MyClass {
private int privateVar = 5; // private access
}

class OtherClass {
void test() {
MyClass obj = new MyClass();
// int x = obj.privateVar; // Error: privateVar not visible
}
}

Root cause:

Confusing default access with private access and their visibility scopes.

#3 Not specifying any access modifier and expecting the member to be public.

Wrong approach:

class MyClass {
void defaultMethod() {
System.out.println("Hello");
}
}

// From another package
MyClass obj = new MyClass();
obj.defaultMethod(); // Error: not visible

Correct approach:

public class MyClass {
public void publicMethod() {
System.out.println("Hello");
}
}

// From another package
MyClass obj = new MyClass();
obj.publicMethod(); // Works

Root cause:

Assuming no modifier means public, ignoring that default access is package-private.

Key Takeaways

The default access modifier in Java means package-private: accessible only within the same package without writing any keyword.

It helps organize code by allowing classes in the same package to share members while hiding them from outside packages.

Default access is more restrictive than protected but less restrictive than private, and it applies to all class members including constructors.

Misunderstanding default access can cause common bugs, especially in inheritance and cross-package access.

Using default access thoughtfully improves encapsulation and maintainability in Java projects.

Practice

1. Which statement best describes the default access modifier in Java?

easy

A. It restricts access only to the class itself.

B. It allows access from any package using the default keyword.

C. It allows access only within the same package without using any keyword.

D. It allows access only to subclasses in other packages.

Solution

1. Step 1: Understand default access modifier meaning

   The default access modifier means no keyword is used before a class, method, or variable, and it restricts access to the same package only.

2. Step 2: Compare options with definition

   It allows access only within the same package without using any keyword. correctly states it allows access only within the same package and requires no keyword. Other options mention keywords or access outside the package, which is incorrect.

3. Final Answer:

   It allows access only within the same package without using any keyword. -> Option C

4. Quick Check:

   Default access = package-only access [OK]

Hint: No keyword means default access is package-only [OK]

Common Mistakes:

• Thinking default requires a keyword
• Confusing default with public or private
• Assuming default allows access from other packages

2. Which of the following is the correct way to declare a class with default access modifier?

easy

A. class MyClass {}

B. private class MyClass {}

C. default class MyClass {}

D. public class MyClass {}

Solution

1. Step 1: Recall syntax for default access modifier

   Default access means no access keyword is written before the class name.

2. Step 2: Check each option

   class MyClass {} declares the class without any access keyword, which means default access. Options A and B use explicit keywords, and C uses a non-existent keyword.

3. Final Answer:

   class MyClass {} -> Option A

4. Quick Check:

   No keyword = default access [OK]

Hint: No keyword before class means default access [OK]

Common Mistakes:

• Using 'default' keyword which does not exist in Java
• Confusing private with default
• Always using public by habit

3. Consider two classes in the same package:

class A {
    void show() {
        System.out.println("Hello from A");
    }
}

class B {
    public static void main(String[] args) {
        A a = new A();
        a.show();
    }
}

What will be the output when class B is run?

medium

A. Compile-time error: show() has private access

B. Hello from A

C. Compile-time error: class A is not public

D. Runtime error

Solution

1. Step 1: Analyze access modifiers in the code

   Class A and method show() have default access (no keyword). Both classes are in the same package, so access is allowed.

2. Step 2: Predict program output

   Since B can access A and its show() method, the program prints "Hello from A" without errors.

3. Final Answer:

   Hello from A -> Option B

4. Quick Check:

   Default access allows same package access [OK]

Hint: Default access works within same package [OK]

Common Mistakes:

• Assuming default means private access
• Thinking class A must be public to be used
• Confusing compile-time and runtime errors

4. Given two packages pkg1 and pkg2, and these classes:

package pkg1;
class C {
    void display() {
        System.out.println("Inside C");
    }
}

package pkg2;
import pkg1.C;
public class D {
    public static void main(String[] args) {
        C c = new C();
        c.display();
    }
}

What is the error in this code?

medium

A. Cannot access class C from pkg2 because it has default access

B. Cannot call display() because it is private

C. Cannot import package pkg1

D. No error, code runs fine

Solution

1. Step 1: Check class C's access modifier and package

   Class C has default access (no keyword) and is in package pkg1, so it is accessible only within pkg1.

2. Step 2: Check usage of C in pkg2

   Class D in pkg2 tries to create an instance of C and call display(), but C is not visible outside pkg1, causing a compile-time error.

3. Final Answer:

   Cannot access class C from pkg2 because it has default access -> Option A

4. Quick Check:

   Default access = package-only visibility [OK]

Hint: Default access blocks cross-package access [OK]

Common Mistakes:

• Assuming default access allows cross-package use
• Thinking display() is private
• Confusing import errors with access errors

5. You have a package tools with classes:

class Helper {
    void assist() {
        System.out.println("Helping...");
    }
}

public class Tool {
    public static void main(String[] args) {
        Helper h = new Helper();
        h.assist();
    }
}

You want to allow only classes inside tools to use Helper and its assist() method, but prevent access from outside. Which is the best way to achieve this?

hard

A. Make Helper and assist() public.

B. Use protected for Helper and assist().

C. Make Helper and assist() private.

D. Keep Helper and assist() with default access (no keyword).

Solution

1. Step 1: Understand access goals

   You want Helper and assist() accessible only inside the same package (tools) and hidden outside.

2. Step 2: Match access modifiers to goals

   Default access (no keyword) restricts access to the same package only, which fits the requirement. Public allows all access, private restricts to the class only, and protected allows subclasses and package access.

3. Final Answer:

   Keep Helper and assist() with default access (no keyword). -> Option D

4. Quick Check:

   Default access = package-only visibility [OK]

Hint: Default access hides from outside packages [OK]

Common Mistakes:

• Using public which exposes to all packages
• Using private which hides even inside package
• Using protected which allows subclass access outside package