8

I was looking through many approaches to implement a Factory pattern in Java and still couldn't find a perfect one which doesn't suffer from both if/switch plus doesn't use reflection. One of the best that I found was inside Tom Hawtin's answer here: https://stackoverflow.com/a/3434505/1390874

But my biggest concern is that it stores a HashMap of Anonymous classes in a memory.

The question is what do people think about using Class.newInstance() in addition to Tom Hawtin's answer? This will avoid us from storing unnecessary anonymous classes in memory? Plus code will be more clean.

It will look something like this:

class MyFactory {
    private static final Map<String,Class> factoryMap =
        Collections.unmodifiableMap(new HashMap<String,Class>() {{
            put("Meow", Cat.class);
            put("Woof", Dog.class);
    }});

    public Animal createAnimal(String action) {
        return (Animal) factoryMap.get(action).newInstance();
    }
}
Community
  • 1
  • 1
goRGon
  • 4,402
  • 2
  • 43
  • 45
  • *still couldn't find a perfect one which doesn't suffer from both if/switch **plus doesn't use reflection*** well, you're contradicting yourself here, aren't you? – Luiggi Mendoza Apr 08 '15 at 02:48
  • *"my biggest concern is that it stores a HashMap of Anonymous classes in a memory"* Why are you concerned about this? It's generally fine. (Though subtly, the way Tom is creating the Map, the anonymous factories have an implicit reference to the Map. Something to be aware of...) – Radiodef Apr 08 '15 at 03:32
  • @LuiggiMendoza, thank you. I thought Cat.class.newInstance() will be not reflection but seems that you are right according to: https://docs.oracle.com/javase/tutorial/reflect/member/ctorInstance.html – goRGon Apr 09 '15 at 01:45
  • @Radiodef, the biggest concert was wasting memory. – goRGon Apr 09 '15 at 01:48
  • I wouldn't worry about that. An anonymous class transforms to a single class file associated with the expression declaring it. A normal program would have 100s or 1000s of classes already. – Radiodef Apr 09 '15 at 01:55

3 Answers3

13

If you are using java 8, you can set up an enum like this:

enum AnimalFarm {
    Meow(Cat::new),
    Woof(Dog::new);

    public final Supplier<Animal> factory;
    private AnimalFarm(Supplier<Animal> factory) {
        this.factory = requireNonNull(factory);
    }
}

......

Animal dog = AnimalFarm.valueOf("Woof").factory.get();

You could even have the enum implement Supplier<Animal> and then do AnimalFarm.valueOf("Meow").get();.

Luiggi Mendoza
  • 85,076
  • 16
  • 154
  • 332
Misha
  • 27,433
  • 6
  • 62
  • 78
  • 1
    Plus 1 for using an enum and no reflection, but that dog won't like being called `cat`! – Paul Boddington Apr 08 '15 at 03:18
  • 1
    Isn't such answer for JDK7 a better approach: http://stackoverflow.com/a/3434505/1390874 – goRGon Apr 09 '15 at 01:03
  • @goRGon I believe Tom is referring to the proposed map literal feature, [which doesn't exist yet](http://stackoverflow.com/a/10705741/2891664). – Radiodef Apr 09 '15 at 01:56
3

Java 8 introduces some nice lambdas and functional interfaces that makes this really easy. It also avoids a lot of the ugly boilerplate code you would have had to write in previous Java versions. One thing that wasn't immediately clear was how to handle creating objects with constructors that take multiple arguments. Most of Java's functional interfaces allow either one argument or no arguments at all. In this case the solution is to implement your own functional interface.

Imagine your Animal classes all had constructors that looked like this:

public Dog(String name, int age) {
    // constructor stuff
}

You can create a function interface called something like Factory in your factory class that has 3 parameters. The first two parameters would be the types of objects you're going to pass to the constructor and the third will be what you're going to return.

public class AnimalFactory {

    private static final Map<String, Factory<String, Animal>> factoryMap;

    static {
        Map<String, Factory<String, Animal>> realMap = new HashMap<>();
        factoryMap = Collections.unmodifiableMap(realMap);

        realMap.put("MEOW", Cat::new);
        realMap.put("WOOF", Dog::new);
    }

    public static Animal createAnimal(String action) {
        return factoryMap.get(action).create(node);
    }

    @FunctionalInterface
    private interface Factory<T, R, S> {
        S create(T obj1, R obj2);
    } 
}

If all your classes use no-arg constructors then you can drop the custom interface and use something like Supplier instead. But everything else should more or less stay the same.

David DeMar
  • 2,390
  • 2
  • 32
  • 45
0

Try something like this:

class MyFactory {
    private static final Map<String,Animal<?>> factoryMap =
        Collections.unmodifiableMap(new HashMap<String,Class>() {
            put("Meow", Cat.BASE_INSTANCE);
            put("Woof", Dog.BASE_INSTANCE);
    });

    public Animal createAnimal(String action) {
        return factoryMap.get(action).instance();
    }
}

interface Animal<SELF> {
    public SELF instance();
}

class Cat implements Animal<Cat> {
    public static final Cat BASE_INSTANCE = new Cat();
    public Cat() {}
    public Cat instance(){
        return new Cat();
    }
}
// And a similar Dog class

This does not use reflection, if, or switch, at all.

k_g
  • 4,333
  • 2
  • 25
  • 40