Better idiom for a factory?

Question

Our project has about 25 exception classes, which are all subclasses of a common exception class (call it FooException) which itself extends java.lang.Exception with some additional functionality to make these exceptions easier to use in our framework.
Until now I had been calling the constructors for each class explicitly, e.g.
throw new NoCoffeeException("out of coffee", t, x);and there were several constructor signatures, depending on the context and the information that needed to be conveyed.
I had most of the code factored out to the FooException superclass, but each subclass still needed each constructor explicitly written, even though they were identical except for the class name.
Now that I need to add about 3 more constructor signatures, I decided this was nuts and am rewriting this to use a factory instead. It's pretty much working as I want except I'm not completely sure of the best way to indicate the desired class to the factory.
What I currently have is:throw FooException.make(NoCoffeeException.class, "out of coffee", t, x);which works fine except I'm not completely thrilled about clients having to say "NoCoffeeException.class". No good reason but it just seems a little ugly and "feels" like it breaks encapsulation.
But I can't think of a better way to indicate it, other than introducing another set of constants, which seems entirely redundant and just as bad.
How does this sit with you? Does this seem natural? Thanks...

Answer 1

Just an off the wall idea (and I have NEVER seen this
before) - a simple constructor with setX() methods?
NoCoffeeException nce = new NoCoffeeException();
nce.setMessage( "Bah!" );
nce.setLocalization( whateverGoesHere );
nce.setThrowable( t );
throw nce;like I said, I've never seen that done with
exceptions, but if you have an IDE with the "right
click->add get/set methods" feature its much faster...Throwable, in J2SE 1.4, has an initCause(Throwable rootCause) method that allows you to chain exceptions, and is usually used just as your setX() methods are. This is often a good way to do it.
As syntactic sugar, initCause() returns 'this', as Throwable, to support method invocation chaining. (Invocation chaining is also all over the java.nio package. See java.nio.Buffer.position() and others for example.) So it could look like this:
try {
  something();
} catch (IOException e) {
  CoffeeException ce = new CoffeeException("Network error");
  ce.initCause(e);
  throw ce;
}or, with invocation chaining:
try {
  something();
} catch (IOException e) {
  throw (CoffeeException) new CoffeeException("Network error").initCause(e);
}Unfortunately (as with java.nio.Buffer) most of the time, you must downcast to the proper type as the superclass method is declared to return Throwable. If only java had covariant return types! Hopefully in Tiger (J2SE 1.5).
See http://developer.java.sun.com/developer/bugParade/bugs/4144488.html for more on covariant return types in Java.
Cheers,
Colin