If these classes really do need to be bound in by Inheritance rather
than delegation, then the best approach for your design problem is to
not use public constructors at all.

Instead, use public factory methods on those classes, protected
constructors and move all logic from constructors into init methods.
This way, you can get full control over what happens.

class Base {
   protected Base() {
   }

   protected init(
     if (someCondition)
        throw new RuntimeException();
   }

   public static Base createBase() {
      Base base = new Base();
      base.init();
      return base;
   }
}

class Derived extends Base {

   protected Derived() {
   }

   protected init() {
      try {
        super.init();
      catch(RuntimeException re) {
        system.out.println(re);
      }
   }

   public static Derived createDerived() {
     Derived derived = new Derived();
     derived.init();
     return derived;
   }

}

sorry, I don't get that ;-) How would something like that help me catch
the exception that super() throws?

/philipp

Yep, and the problem of course is that a try/catch block is not used
merely to ignore exceptions, but also to wrap them... which may be a
quite sensible thing to want to do.

In this case, though, it appears there's something wrong with the
inheritance structure.

Yeah, I was going to ask what's wrong with Factory that makes such
"solutions" seem attactive to people.  I suspect that's just because
there are people who haven't read GoF or its derivatives, and who are
struggling to find an approach to a common problem on their own.  

That's what I mean :-)