Static factory methods vs Instance (normal) constructors?
coding-style, constructor, design-patterns
Solution
In Effective Java, 2nd edition, Joshua Bloch certainly recommends the former. There are a few reasons I can remember, and doubtless some I can't:
- You can give the method a meaningful name. If you've got two ways of constructing an instance both of which take an int, but have different meanings for that int, using a normal method makes the calling code much more readable.
- A corollary of the first - you can have different factory methods with the same parameter list
- You can return null for "potentially expected failure" cases whereas a constructor will always either return a value or throw an exception
- You can return a type other than the declared (e.g. return a derived class)
- You can use it as a factory, to potentially return a reference to the same object several times
The downsides:
- It's not as idiomatic, currently - developers are more used to seeing "new"
- If you see "new" you know you're getting a new instance (modulo the oddity I mentioned recently)
- You need to make appropriate constructors available for subclasses
- In C# 3, constructor calls are able to set fields/properties in a compact manner with object initializer expressions; the feature doesn't apply to static method calls
Problem
In a language where both are available, would you prefer to see an instance constructor or a static method that returns an instance? For example, if you're creating a `String` from a `char[]`: `String.FromCharacters(chars);` `new String(chars);`