Re: Question on member accessibility

ankur wrote:


<Geeky JLS reference>
?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.
</Geeky JLS reference>

To be specific:
public class A {
    protected int field;
    protected void method() {}

    protected A() {}
}

class B extends A {
   public B() {
      super();
      this.field = 9;
      this.method();
   }

   /*public static void methodA(A a) {
     if (a.field == 0)
       a.method();
   }*/

   public static void methodB(B b) {
     if (b.field == 0)
       b.method();
   }

   public void methodC(A a) {
     if (this.field == 0)
       this.method();

     //if (a.field == 0)
     // a.method();
   }
}
class C {
   public void method() {
     //A a = new A();
     A a = new A() { public void method() {} };
   }
}

Classes B and C are in a different package from A. The commented out
lines are lines that won't compile because they do not have right
access. The other lines do have right access.

To briefly summarize: a protected member can only be accessed outside of
the package if the accessor "needs" it to implement (e.g., access to the
constructor) or if the object is of the type of the subclass. Hence the
inability to access a.field but the ability to access b.field or this.field.

I don't know the entire rationale behind this, but this is my guess. The
purpose of protected, in the inheritance sense, is to say that "this
property is one I wish to expose to people who need to implement me but
not those who wish to merely use me." So, let us form the class:

class Foo {
   protected int importantFieldForInternalUse;
}

Since it's internal, we don't want people mucking about with it, but our
subclass needs to use it. But Joe Hacker comes along and says "if only I
change that important field..." Since Foo is created by other stuff and
passed around by methods, he gets a hold of it to his class:

class Evil extends Foo {
   public static void manipulateFoo(Foo object) {
     // Bwa-ha-ha! I broke it all!
     object.importantFieldForInternalUse = 0;
   }
}

Obviously, this is really an external use, not the intended internal
use. So by requiring that the object be of the subtype before you can
get to it, you enforce the notion that protected means "for
implementation purposes only."

Hope this brings some light on the situation.

--
Beware of bugs in the above code; I have only proved it correct, not
tried it. -- Donald E. Knuth