Re: Why is a static protected field NOT protected as seems it should?
Norman wrote:
Why is a static protected field NOT protected as seems it should?
The non static protected field is protected as it should be according
to the book. See comments/questions below.
....
package app2;
public class classtest extends app1.Main {
The class name should follow the convention of starting with an upper-case
letter and using camel case thereafter.
public void amethod(app1.Main m, classtest c) {
Notice that argument 'm' is passed in from the "outside", so to speak. That
is relevant to the behavior you ask about.
System.out.printf("amethod");
// vvv Why doesn't netbeans [sic] complain about this?
It's not so mucn NetBeans itself as that it's following the rules of the Java
compiler.
// Isn't sprotect protected in the same manner as protect?
System.out.printf("sprotect\n", app1.Main.sprotect);
This access is by class reference to a static member, through the supertype
'app1.Main'. This counts as walking up the subclass's own hierarchy from
"within itself", so to speak, thus fulfilling
?6.6.2:
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. [ The JLS then goes on to qualify this more
explicitly ]
as cited by Joshua Cranmer. The static reference is going up through this
class's own inheritance as seen by its own implementation.
System.out.printf("pprotect\n", app1.Main.spub);
System.out.printf("protect\n", protect);
This instance reference is to the object's own internal instance variable 'pub':
System.out.printf("pubprotect\n", pub);
Now you switch to instance reference, using arguments 'm' and 'c' passed in
from the "outside":
// vvv protect has protected access in app1.Main
System.out.printf("protect\n", m.protect);
System.out.printf("pubprotect\n", m.pub);
System.out.printf("protect\n", c.protect);
System.out.printf("pubprotect\n", c.pub);
}
}
Because those last protected references are through another object, not
through 'this', they are not part of the instance's own knowledge of itself.
It can know these things about itself, but not about the other objects, even
though they be of the same type or subtype thereof.
The 'public' attribute should have raised no warning.
--
Lew