Re: Constructor
On Sat, 27 Sep 2008, zerg wrote:
Tom Anderson wrote:
On Fri, 26 Sep 2008, Mark Space wrote:
public class Factory {
private Factory() {}
public static Wrapper getNew( Implementation i ) {
Wrapper w = new Wrapper( i );
Registry.register( w ); // not shown
return w;
}
}
This more or less what i was thinking - convert inheritance to composition,
and do the registration in the wrapper after the implementation is
constructed.
This also resembles decorator, but the changeable part is the core instead of
the wrapper.
Of course, calling subclass specific methods might be a pain,
Yes - if the subclasses extend the interface rather than just the
implementation, this approach doesn't work at all.
unless you use generics to make the wrapper a kind of "one-element
container" with a get method that returns the object.
The wrapper would be better named something like "RegisteredFoo" to
indicate that it wraps a Foo and registers it -- wherever the Foo that
is passed in must be registered something like RegisteredFoo<?> would be
the parameter type instead of just Foo.
Not a bad idea. If you do this, it really does start to look a lot like
Decorator, you're right.
My second approach, of not using a wrapper but doing the registration
post-construction in a factory method, lets the subclasses extend the
interface, but since the factory method returns the base type, you do have
to do an explicit cast first.
Although you could do something like this:
public <T extends Implementation> T create(Class<T> implClass) {
T impl = implClass.newInstance() ;
register(impl) ;
return impl ;
}
You could use a more complicated reflective invocation instead of
newInstance, or you could do something clever with factories:
public <T extends Implementation> T create(ImplFactory<T> implFactory) {
T impl = implFactory.create(some args) ;
register(impl) ;
return impl ;
}
The trouble with this is you then have to write factories for each
implementation subclass, and it starts to look like you've got at least
one too many layers of indirection here!
tom
--
unstable orbits in the space of lies