Factory Without IF-ELSE

Object Oriented Language has very powerful feature of Polymorphism, it is used to remove if/else or switch case in code.

Code without condition is easy to read. There are some places where you have to put them and one of such example is Factory/ServiceProvider class.

I am sure you have seen factory class with IF-ELSEIF which keeps on getting big.

In this blog i will share some techniques that you can be used to remove condition in factory class.

I will use below code snippet as example

	public static Validator newInstance(String validatorType) {
	if ("INT".equals(validatorType))
	return new IntValidator();
	else if ("DATE".equals(validatorType))
	return new DateValidator();
	else if ("LOOKUPVALUE".equals(validatorType))
	return new LookupValueValidator();
	else if ("STRINGPATTERN".equals(validatorType))
	return new StringPatternValidator();
	return null;
	}

view raw ValidatorFactory hosted with ❤ by GitHub

Reflection
This is first thing that comes to mind when you want to remove conditions. You get the feeling of framework developer!

	public static Validator newInstance(String validatorClass) {
	return Class.forName(validatorClass).newInstance();
	}

view raw Reflection hosted with ❤ by GitHub

This looks very simple but only problem is caller has to remember fully qualified class name and some time it could be issue.

Map
Map can be used to to map actual class instance to some user friendly name

	Map<String, Validator> validators = new HashMap<String,Validator>(){
	{
	put("INT",new IntValidator());
	put("LOOKUPVALUE",new LookupValueValidator());
	put("DATE",new DateValidator());
	put("STRINGPATTERN",new StringPatternValidator());
	}
	};
	public Validator newInstance(String validatorType) {
	return validators.get(validatorType);
	}

view raw MapFactory hosted with ❤ by GitHub

This also looks neat without overhead of reflection.

Enum
This is interesting one

	enum ValidatorType {
	INT {
	public Validator create() {
	return new IntValidator();
	}
	},
	LOOKUPVALUE {
	public Validator create() {
	return new LookupValueValidator();
	}
	},
	DATE {
	public Validator create() {
	return new DateValidator();
	}
	};
	public Validator create() {
	return null;
	}
	}
	public Validator newInstance(ValidatorType validatorType) {
	return validatorType.create();
	}

view raw EnumFactory hosted with ❤ by GitHub

This method is using enum method to remove condition, one of the issue is that you need Enum for each type. You don't want to create tons of them!
I personally like this method.

 Conclusion
If-else or switch case makes code difficult to understand, we should try to avoid them as much as possible. Language construct should be used to avoid some of switch case.

We should try to code without IF-ELSE and that will force us to come up with better solution.