Call protected method from a subclass of another instance of different packages

java subclass packages protected access-modifiers

35,464

Solution 1

You could access the protected methods either by subclassing and overriding; also when they are available in the same package. I will add some details. You can read details here.

The example that you have is on lines of the protected clone() method available in the Object class in java; you cannot directly call it on any object (although all object implicitly extend from the Object class).

Solution 2

Don't know the rationale, but JLS confirms this in 6.6.2. Details on protected Access (emphasis mine):

A protected member or constructor of an object may be accessed from outside the package in which it is declared only by code that is responsible for the implementation of that object.

So:

package P2;
public class P2 {
    protected void foo() {}
}

.........

package P2A;    
class P2A extends P2.P2 {
    void bar(P2.P2 other) {
        this.foo(); // OK
        other.foo();  // ERROR
    }

    void bar2(P2A other) { 
        other.foo(); //OK
    }
}

In P2A.bar a call to this.foo() is accessible because this is responsible for implementation of P2 but other.foo() is not accessible because other may not be a P2A. bar2 on the other hand has a P2A so it is all good.

Now, why all is OK if they are all the same package but not if they are different packages? What is the rationale? I don't know and would like to know.

Meta-Comment I have rolled back a recent update by another user as it substantially changes the answer and is probably more suitable as a top level answer itself.

35,464

Author by

Niklas R

Updated on December 19, 2020

Comments

Niklas R over 3 years
I want to invoke a protected method of another instance from within a subclass of the class providing this protected method. See the following example:
```
public class Nano {

    protected void computeSize() {
    }

}

public class NanoContainer extends Nano {

    protected ArrayList<Nano> children;

}

public class SomeOtherNode extends NanoContainer {

    // {Nano} Overrides

    protected void computeSize() {
        for (Nano child: children) {
            child.computeSize();            // << computeSize() has protected access in nanolay.Nano
        }
    }

}
```
javac tells me that computeSize() has protected access in Nano. I can't see the reason for this (I thought I was already doing this in some other code). I'd like to keep this method being protected, what can I do?
```
javac version "1.7.0_09"
```
Edit

I wanted to provide a stripped down version, but I didn't think about the fact, that the classes lie in different packages.
```
nanolay.Node
nanolay.NanoContainer
nanogui.SomeOtherNode
```
Niklas R over 11 years

But I cannot subclass and call the method on another instance of the superclass, as I'm doing above? (Assuming they are in different packages, because it works when they are in the same package)
Scorpion over 11 years

An instance of someothernode object has access to the protected computeSize method but not of some other instance of someothernode - so not in the for loop.
Niklas R over 11 years

Thanks for this summary, I definately agree with you. This behavior does not seem legit to me.
Miserable Variable over 11 years

@Scorpion that seems incorrect. This compiles without error if they are all in same package.
Miserable Variable over 11 years

clone cannot be called because it is protected in Object, which is in package java.lang and this class is not in that package.
Miserable Variable over 11 years

Perhaps you can ask another question about the rationale> It may not be suitable for this forum, but programmers likes these types of questions
Scorpion over 11 years

Yes, it would compile correctly if all the classes are in the same package. The clone example illustrates that - a protected method in a different package cannot be invoked; so you create an employee class outside java.lang, so the clone method on this employee class object cannot be invoked unless it exposes it via public modifier
amarnath harish almost 6 years

why other has to be P2A isnt it enough for it to be P2.P2 to access foo(); since foo is declared in P2.P2. please clarify
Admin almost 6 years

"to accessing protected members or protected methods from outside the same package you cant use the parent class object, only implementing class object can be used to access the protected members of parent class outside same package"
Chandan Gupta almost 3 years

What if I write like P2 p = new P2A(); p.foo(); Even this is not allowed, I am wondering why?