Protected Field

A protected field in Java is a member field declared with the protected access modifier, restricting its visibility to the declaring class, classes within the same package, and subclasses located in any package. It provides a strictly wider access level than package-private (default) visibility by explicitly permitting cross-package access strictly through inheritance.

Syntax

The protected keyword precedes the data type in the field declaration:

protected [data_type] [identifier];
protected static [data_type] [identifier];

Visibility Matrix

Java enforces the following access boundaries for a protected field:

• Same Class: Accessible
• Same Package (Subclass): Accessible
• Same Package (Non-subclass): Accessible
• Different Package (Subclass): Accessible (with strict inheritance context constraints)
• Different Package (Non-subclass): Not Accessible

Cross-Package Inheritance Mechanics

The most complex mechanical rule regarding protected fields involves cross-package access. When a subclass resides in a different package than the superclass defining the protected field, the subclass can only access the protected field through an inheritance context. The rules differ depending on whether the field is an instance field or a static field.

• Instance Fields: The subclass can access the field on instances of itself or its own subclasses. It cannot access the protected field on an object reference of the superclass type.
• Static Fields: The subclass can access a protected static field via its own type name (or implicitly without qualification). It cannot access the protected static field via the superclass type name.

Code Demonstration

// Package A
package com.example.core;

public class BaseClass {
    protected int instanceState;
    protected static int staticState;
}

// Package B
package com.example.extension;

import com.example.core.BaseClass;

public class DerivedClass extends BaseClass {
    
    public void modifyState() {
        // --- INSTANCE FIELD ACCESS 
        
        // VALID: Implicitly accessing via 'this' (inheritance context)
        instanceState = 10; 
        
        // VALID: Explicitly accessing via 'this'
        this.instanceState = 20; 
        
        // VALID: Accessing via an instance of the same subclass
        DerivedClass derivedInstance = new DerivedClass();
        derivedInstance.instanceState = 30; 
        
        // INVALID: Compilation Error. 
        // Cannot access protected instance field on an object reference of the superclass type.
        BaseClass baseInstance = new BaseClass();
        // baseInstance.instanceState = 40; 
        
        
        // --- STATIC FIELD ACCESS 
        
        // VALID: Accessing via the subclass type name
        DerivedClass.staticState = 50;
        
        // INVALID: Compilation Error.
        // Cannot access protected static field via the superclass type name
        // from a different package.
        // BaseClass.staticState = 60;
    }
}

Access Enforcement and Memory Model

The protected modifier is enforced at both compile-time and run-time. At compile-time, javac validates the access boundaries. At run-time, the JVM enforces these boundaries during resolution and linkage, throwing an IllegalAccessError if a violation occurs (e.g., if class files were recompiled separately and access levels changed). Additionally, the Reflection API enforces these rules dynamically, throwing an IllegalAccessException if unauthorized access is attempted.

Applying the protected modifier does not alter how the field is allocated in memory. During object instantiation, memory is allocated for a protected instance field on the Heap exactly as it would be for private, public, or default fields. Protected static fields are stored on the Heap as part of the java.lang.Class instance during class loading, identical to other static fields.

Master Java with Deep Grasping Methodology!

Learn More