Java Protected Method

A protected method in Java is a class member defined with the protected access modifier, restricting its visibility to the declaring class, classes within the same package, and subclasses located in any package. It establishes an access level that is strictly wider than default (package-private) visibility but more restrictive than public visibility.

public class SuperClass {
    protected void executeTask() {
        // Method implementation
    }
}

Visibility Rules

The Java compiler enforces the following access boundaries for a protected method:

Same Class: Accessible.
Same Package (Subclass): Accessible.
Same Package (Non-subclass): Accessible.
Different Package (Subclass): Accessible (with strict instance restrictions).
Different Package (Non-subclass): Not accessible.

Cross-Package Subclass Access Restriction

When a subclass resides in a different package from the superclass declaring the protected method, the subclass can only invoke the method through inheritance on instances of its own type (or its own subclasses). It cannot invoke the protected method on a direct reference of the superclass type.

package com.example.parent;

public class Parent {
    protected void initialize() {}
}

package com.example.child;

import com.example.parent.Parent;

public class Child extends Parent {
    public void testAccess() {
        // Valid: Accessing via inheritance (implicit 'this')
        initialize(); 
        
        // Valid: Accessing via instance of the subclass
        Child childInstance = new Child();
        childInstance.initialize(); 
        
        // Invalid: Compilation error. Cannot access via superclass reference 
        // from a different package.
        Parent parentInstance = new Parent();
        // parentInstance.initialize(); 
    }
}

Method Overriding Constraints

According to the Java Language Specification (JLS), when a subclass overrides a protected method, the access modifier of the overriding method must provide equal or wider visibility.

Permitted: Overriding as protected or public.
Compilation Error: Overriding as default (package-private) or private.

package com.example.other;

import com.example.parent.Parent;

public class SubClass extends Parent {
    // Valid: Widening visibility
    @Override
    public void initialize() {
        super.initialize();
    } 
    
    // Invalid: Narrowing visibility (Compilation Error)
    // @Override
    // void initialize() {} 
}

Interface Restrictions

The protected modifier cannot be applied to methods declared within an interface. Interface methods are implicitly public (or explicitly private as of Java 9). Attempting to declare an interface method as protected violates the JLS and will result in a compilation error.

Tired of Poor Java Skills? Fix That With Deep Grasping!Learn More

Methods

Classes

Constructors

Type Declarations

Lambdas & Method References

Generics

Pattern Matching

Variables

Fields

Parameters

Annotations

Nested Classes

Exception Handling

Control Flow

Loops

Packages & Imports

Primitive Types

Comments

Comparison Operators

Logical & Conditional Operators

Arithmetic Operators

Assignment Operators

Type Operators

Unary Operators

Bitwise Operators

Shift Operators

Java Protected Method

Visibility Rules

Cross-Package Subclass Access Restriction

Method Overriding Constraints

Interface Restrictions

​Visibility Rules

​Cross-Package Subclass Access Restriction

​Method Overriding Constraints

​Interface Restrictions

Visibility Rules

Cross-Package Subclass Access Restriction

Method Overriding Constraints

Interface Restrictions