Protected access modifier in Java - Time & Space Complexity

Time Complexity: Protected access modifier

O(n)

Understanding Time Complexity

Let's explore how the protected access modifier affects the time complexity of method calls in Java.

We want to see how the program's work grows when using protected methods in inheritance.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Parent {
    protected void display() {
        System.out.println("Parent display");
    }
}

class Child extends Parent {
    @Override
    protected void display() {
        super.display();
        System.out.println("Child display");
    }
}

public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        c.display();
    }
}
    

This code shows a protected method called in a child class that overrides the parent method and calls it.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Method calls to display() in parent and child classes.
• How many times: Called once in main, no loops or recursion involved.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
1	2 method calls (parent and child)
10	20 method calls if repeated 10 times
100	200 method calls if repeated 100 times

Pattern observation: The number of method calls grows linearly with how many times display() is called.

Final Time Complexity

Time Complexity: O(n)

This means the work grows directly in proportion to how many times the protected method is called.

Common Mistake

[X] Wrong: "Protected methods slow down the program because of access checks every time."

[OK] Correct: Access checks happen at compile time, not during each call, so runtime speed is not affected by the protected modifier.

Interview Connect

Understanding how protected methods behave helps you explain inheritance and method overriding clearly, a key skill in many Java discussions.

Self-Check

What if the display() method was called inside a loop 1000 times? How would the time complexity change?

Practice

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

easy

A. It allows access only within the same class.

B. It allows access only within the same package, not subclasses outside.

C. It allows access from any class anywhere.

D. It allows access within the same package and to subclasses outside the package.

Solution

1. Step 1: Understand protected access scope

   The protected modifier allows access to members within the same package and also to subclasses even if they are in different packages.

2. Step 2: Compare with other access levels

   Private restricts access to the same class only, public allows everywhere, and default (package-private) allows only within the same package but not subclasses outside.

3. Final Answer:

   It allows access within the same package and to subclasses outside the package. -> Option D

4. Quick Check:

   Protected = same package + subclasses outside [OK]

Hint: Protected means package + subclass access [OK]

Common Mistakes:

• Confusing protected with private
• Thinking protected is public
• Assuming protected restricts subclasses outside package

2. Which of the following is the correct way to declare a protected method in Java?

easy

A. private protected void myMethod() {}

B. public protected void myMethod() {}

C. protected void myMethod() {}

D. void protected myMethod() {}

Solution

1. Step 1: Recall Java access modifier syntax

   In Java, access modifiers come before the return type and method name. Only one access modifier is allowed per method declaration.

2. Step 2: Identify valid syntax

   protected void myMethod() {} correctly uses protected followed by the return type void and method name. Other options combine modifiers incorrectly or place them in wrong order.

3. Final Answer:

   protected void myMethod() {} -> Option C

4. Quick Check:

   Single access modifier before return type [OK]

Hint: Use only one access modifier before return type [OK]

Common Mistakes:

• Combining multiple access modifiers
• Placing modifiers after return type
• Using invalid modifier combinations

3. Consider the following code in two packages:

package pkg1;
public class Parent {
    protected int value = 10;
}

package pkg2;
import pkg1.Parent;
public class Child extends Parent {
    public int getValue() {
        return value;
    }
}

public class Test {
    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.getValue());
    }
}

What is the output when running Test.main?

medium

A. 0

B. 10

C. Compilation error due to access

D. Runtime error

Solution

1. Step 1: Check access of protected member in subclass outside package

   The value field is protected in Parent. The Child class extends Parent and accesses value in getValue(). This is allowed because protected permits subclass access even outside the package.

2. Step 2: Trace the output of getValue()

   The method returns value which is initialized to 10. So, printing c.getValue() outputs 10.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Protected allows subclass access outside package [OK]

Hint: Protected allows subclass access outside package [OK]

Common Mistakes:

• Thinking protected blocks subclass outside package
• Expecting compilation error
• Confusing default access with protected

4. Identify the error in the following code:

package pkg1;
public class Parent {
    protected int data = 5;
}

package pkg2;
import pkg1.Parent;
public class Other {
    public void printData() {
        Parent p = new Parent();
        System.out.println(p.data);
    }
}

medium

A. Cannot access protected member from non-subclass in different package

B. No error, code runs fine

C. Syntax error in import statement

D. Cannot create instance of Parent class

Solution

1. Step 1: Analyze access of protected member from non-subclass outside package

   The class Other is not a subclass of Parent and is in a different package. Accessing p.data is not allowed because protected members are accessible only within the same package or subclasses outside the package.

2. Step 2: Identify the error type

   This causes a compilation error due to illegal access of a protected member from a non-subclass outside the package.

3. Final Answer:

   Cannot access protected member from non-subclass in different package -> Option A

4. Quick Check:

   Protected blocks non-subclass outside package [OK]

Hint: Protected blocks non-subclass outside package [OK]

Common Mistakes:

• Assuming protected allows all package access
• Confusing subclass and non-subclass access
• Ignoring package differences

5. You have a class Animal in package zoo with a protected method makeSound(). You want to allow only subclasses in any package to use makeSound(), but prevent other classes in the same package from calling it. How can you achieve this?

hard

A. Declare makeSound() as protected and move other classes out of the package.

B. Declare makeSound() as protected and make other classes subclasses of Animal.

C. Declare makeSound() as private and provide a public wrapper method.

D. Declare makeSound() as protected and keep other classes in the same package.

Solution

1. Step 1: Understand protected access within package and subclasses

   Protected members are accessible to all classes in the same package and to subclasses outside the package. So, classes in the same package can call makeSound() even if they are not subclasses.

2. Step 2: Restrict access to only subclasses

   To prevent other classes in the same package from accessing makeSound(), you must move those classes to a different package. Then only subclasses (in any package) can access the protected method.

3. Final Answer:

   Declare makeSound() as protected and move other classes out of the package. -> Option A

4. Quick Check:

   Protected allows package + subclass; move non-subclass classes out [OK]

Hint: Protected allows package access; move classes to restrict [OK]

Common Mistakes:

• Thinking protected blocks same-package classes
• Making other classes subclasses to restrict access
• Using private which blocks subclasses