Re: passing a Factory to a method to create a generic instance
Tom Anderson wrote:
How about doing the assignmentLoad in the constructor? That would mean
you have to mass the ios into the constructor, which means using some
more complicated reflection to invoke it, rather than newInstance. I
think like this:
Class<AssignmentLoadable> cl = determineObjectClass() ;
AssignmentLoadable a = cl.getConstructor(IOStream.class).newInstance(ios) ;
So why not use the constructor:
For me, there are two issues. First, a class may have more than one
constructor, and it can be difficult to know, based on just data input,
exactly which constructor should be called.
Second, constructors are not inherited and can't be members of an
interface. Thus, like statics, they're also inconvenient to use. You
can't be assured that a sub-class of another class implements all the
same signatures that the super class does (because they aren't inherited).
AssignementLoadable otoh is guaranteed to exist, because it's a public
member of the super class. The sub-class must have the assignmentLoad
method, either by overloading it or by inheritance.
Using just the default constructor makes it easy to know which
constructor to call: it's always the default one. If a class doesn't
have a default constructor, then I can't instantiate it with this
routine, of course, but that's as close as I can't get to a guaranteed
constructor.
Then a series of getters and setters will configure the class. While
there's other ways to do this (Serializable, for example), assuming
setters seems the easiest way of reading a class from a arbitrary
format. You just assume each data item has a corresponding setter, a
simple 1-to-1 mapping.
I don't feel there's any danger here that's different that using a Java
bean, which is basically initialized and created the same way. The
object is correctly created by it's constructor. There's no "danger"
past that point.
Once you get into Serializable a bit more, I think it's possible to
create immutable objects and such, in a single method call, not split
like mine. However this is a lot more sophisticated use of the
language. Mine is just a simple example of one way to do it.