jlu...@gmail.com wrote:

the following:

public class MySuper {
 Logger l_ ;
 public MySuper(Logger l) {
   l_ = l ;
 }
}

would force your subclasses to at least consciously set the logger,
e.g.:

// ...produces a compilation error
public class MySub : extends MySuper {
 public MySub() {
 }
}

// ...requires syntax like:
public class MySub extends MySuper {
 public MySub() {
   super(new Logger()) ;
 }
}

// ...or
public class MySub extends MySuper {
 public MySub(Logger l) {
   super(l) ;
 }
}

// ...etc.

If it were my program, I would pass the logger to the constructor of the
subclass so that it is available to the subclass's method when it is needed.
Any code that instantiate the subclass would then have to supply a value for
the Logger or it would cause a compiler error.

Now, the value passed in the statement that instantiates the subclass could
pass a null value for the Logger and that would satisfy the compiler. I
would deal with that problem by checking the Logger value in the constructor
of the subclass; if it is null, throw an IllegalArgumentException. That, of
course, is a runtime error, not a compile error, but I don't know of any
better solution.

Rhino

   shakah gave a good solution. Here's an alternative:

<code>
abstract class MySuperClass {
 protected abstract Logger getLogger();
}

class MySubClass extends MySuperClass {
 private Logger myLogger = new Logger();

 public void someMethod{
   this.getLogger().info("Hello");
 }

 protected Logger getLogger() {
   return this.myLogger;
 }
}
</code>

   The abstract getter is usually a good reminder for implementors of
subclasses that they MUST create a logger.

   - Oliver