Re: passing a Factory to a method to create a generic instance
On Sat, 10 May 2008, thufir wrote:
On Sat, 10 May 2008 01:19:13 +0100, Tom Anderson wrote:
Before i go on, i should say that in the classical application of the
Factory pattern, yes, you would make something more specific than an
Object, because the different factories would be making different
versions of something, or the same thing in different ways. Like you
might define a WidgetFactory, then have concrete factories that make
Nut, Bolt, Screw, etc objects, all of which are subtypes of Widget.
Does there have to be a Nut factory, or can I just use the Widget factory?
I'm not seeing the advantage of WidgetFactory, because I don't seem able
to use it.
WidgetFactory is abstract. NutFactory etc are concrete implementations of
it. Sorry if i haven't explained this clearly.
abstract class Widget {
}
class Nut extends Widget {
}
class Bolt extends Widget {
}
abstract class WidgetFactory {
abstract Widget make() ;
}
class NutFactory extends WidgetFactory {
Widget make() {
return new Nut() ;
}
}
class BoltFactory extends WidgetFactory {
Widget make() {
return new Bolt() ;
}
}
// a usage example
class CratePacker
{
Crate pack(int number, WidgetFactory fac) {
Crate c = new Crate() ;
for (int i = 0 ; i < number ; ++i)
c.add(fac.make()) ;
return c ;
}
}
The point is to be able to pack crates of widgets with one method, which
can be parameterised with a factory which defines the kind of widget.
For me, DataFactory rather than WidgetFactory:
Guest extends Data //Data is just the name of package
Room extends Data //non-inspiring name
public class DataFactory implements Factory<Data> {
public Data make(List<String> data) {return new Data(data);}
}
public interface Factory <T>{
public T make(List<String> data);
}
Nope. You can't make a Data directly - that's why you need separate
subclasses of factory for Guest and Room. This is, in fact, the whole
reason for the factory pattern.
This is the error:
a00720398/bedz/Bedz.java:24: incompatible types
found : java.util.List<a00720398.data.Data>
required: java.util.List<a00720398.data.Room>
rooms = FileUtil.load(roomsFile, new DataFactory());
^
1 error
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/bedz/Bedz.java
package a00720398.bedz;
public class Bedz {
//deleted some stuff
public static void main (String[] args){
/* how do I pass a DataFactory()?
rooms = FileUtil.load(roomsFile, new DataFile()); //error
*/
rooms = FileUtil.load(roomsFile, new RoomFactory());
guests = FileUtil.load(guestsFile, new GuestFactory());
FileUtil.output(rooms,new File("out.txt"));
}
}
thufir@arrakis:~/bcit-comp2611-project1$
I think you've just proved the point. You need a RoomFactory and a
GuestFactory, which are both subtypes of some abstract DataFactory.
Apologies for not explaining this clearly - but i think you really should
spend some time reading existing documentation of the factory pattern.
tom
--
Finals make a man mean; let's fusc up and write!