Protected methods in abstract classes

Question

Hello All
I have some problem which I cannot find a workaround for.
I have three classes:
package my.one;
public abstract class First {
  protected void do();
  protected void now();
package my.one;
public class NotWantToHave extends First {
  protected First obj;
  public NotWantToHave(First O) { obj = O; }
  public void do() { obj.do(); }
  public void now() { obj.now(); }
package my.two;
public class Second extends my.one.First {
  protected void do() { System.out.println("Second does"); }
  protected void now() { System.out.println("Second does now"); }
package my.three;
public class Three extends my.one.First {
  protected my.one.First obj;
  public Three(my.one.First O) { obj = O; }
  protected void do() { System.out.println("Doing"); }
  protected void now() { obj.now(); } // Not possible, see later text
Problem is, as one can read in http://java.sun.com/docs/books/tutorial/java/javaOO/accesscontrol.html , it says that you cannot access protected members and methods from classes if they are in a different package. However, since my class Three should not concern about the method now() but should use from some other class that implements (i.e. class Second), the question I have is how to do?
One way would be to implement a class that simply make a forward call to any protected method in the same package the abstract class is in like in class NotWantToHave and pass it to the constructor of class Third while this class was created with an instance of class Second. However, such a call would look very clumsy (new my.three.Third(new my.one.NotWantToHave(new my.two.Second()));). Furthermore, everyone could create an instance of class NotWantToHave and can invoke the methods defined as protected in class First, so the access restriction would be quite useless.
Does anyone has a good idea how to do?

Answer 1

Hi
One way I found is to have a nested, protected static final class in my super-class First and provide a protected static final method that returns a class where all methods of the super-class are made public and thus accessible from sub-classes at will. The only requirement is that a sub-class must invoke this method to encapsulate other implementations of the super-class and never publish the wrapper class instance. This will look as follows:
package my.one;
public abstract class First {
  protected final static class Wrap extends First { // extend First to make sure not to forget any abstract method
    protected First F;
    public void do() { F.do(); }
    public void now() { F.now(); }
    protected Wrap(First Obj) { F = Obj; }
  } // end Wrap
  protected final static First.Wrap wrap(First Obj) { return new First.Wrap(Obj); }
  protected abstract void do();
  protected abstract void now();
} // end First*******
package my.two;
public class Second extends my.one.First {
  protected void do() { System.out.println("Second does"); }
  protected void now() { System.out.println("Second does now"); }
} // end Second*******
package my.three;
public class Three extends my.one.First {
  protected my.one.First.Wrap obj;
  public Three(my.one.First O) { obj = my.one.First.wrap(O); }
  protected void do() { System.out.println("Doing"); }
  protected void now() { obj.now(); } // Not possible, see later text
} // end Third*******
In this way, I can access all methods in the abstract super class since the Wrap class makes them public while the methods are not accessible from outside the package to i.e. a GUI that uses the protocol.
However, it still looks clumsy and I would appreciate very much if someone knows a more clear solution.
And, please, do not tell me that I stand on my rope and wonder why I fall down. I hope I know what I am doing and of course, I know the specification (why else I should mention about the link to the specification and refer to it?). But I am quite sure that I am not the first person facing this problem and I hope someone out there could tell me about their solution.
My requirements are to access protected methods on sub-classes of a super-class that are not known yet (because they are developed in the far, far future ...) in other sub-classes of the same super-class without make those methods public to not inveigle their usage where they should not be used.
Thanks