package packageOne;
public class Base
{
protected void display(){
System.out.println("in Base");
}
}
package packageTwo;
public class Derived extends packageOne.Base {
public void show(){
new Base().display(); //this is not working throws compilation error that display() from the type Base is not visible
new Derived().display(); //is working
display(); //is working
}
}
The two packages are in two different files. But why this behaviour?
protected
allows access from subclasses and from other classes in the same package. That's why any Derived
class instance can access the protected method in Base
.
The other line creates a Base
instance (not a Derived
instance!!). And access to protected methods of that instance is only allowed from objects of the same package.
display();
-> allowed, because the caller, an instance of Derived
has access to protected members and fields of its subclasses, even if they're in different packages
new Derived().display();
-> allowed, because you call the method on an instance of Derived
and that instance has access to the protected methods of its subclasses
new Base().display();
-> not allowed because the caller's (the this
instance) class is not defined in the same package like the Base
class, so this
can't access the protected method. And it doesn't matter - as we see - that the current subclasses a class from that package. That backdoor is closed ;)