When to use a Constructor and when to use getInstance() method (static factory methods)?
java
Solution
Everybody seems to focus on singletons while I think that the question is actually about constructor vs static factory methods.
This is actually Item 1: Consider static factory methods instead of constructors of Effective Java by Joshua Bloch:
Item 1: Consider static factory methods instead of constructors
The normal way for a class to allow a client to obtain an instance of itself is to provide a public constructor. There is another technique that should be a part of every programmer’s toolkit. A class can provide a public static factory method, which is simply a static method that returns an instance of the class. Here’s a simple example from `Boolean` (the boxed primitive class for the primitive type `boolean`). This method translates a boolean primitive value into a `Boolean` object reference:
public static Boolean valueOf(boolean b) {
return b ? Boolean.TRUE : Boolean.FALSE;
}
Note that a static factory method is not the same as the Factory Method pattern from Design Patterns [Gamma95, p. 107]. The static factory method described in this item has no direct equivalent in Design Patterns.
A class can provide its clients with static factory methods instead of, or in addition to, constructors. Providing a static factory method instead of a public constructor has both advantages and disadvantages.
Advantages (quoting the book):
- One advantage of static factory methods is that, unlike constructors, they have names.
- A second advantage of static factory methods is that, unlike constructors, they are not required to create a new object each time they’re invoked.
- A third advantage of static factory methods is that, unlike constructors, they can return an object of any subtype of their return type.
- A fourth advantage of static factory methods is that they reduce the verbosity of creating parameterized type instances.
Disadvantages (still quoting the book):
- The main disadvantage of providing only static factory methods is that classes without public or protected constructors cannot be subclassed.
- A second disadvantage of static factory methods is that they are not readily distinguishable from other static methods.
Problem
When and how should we use a constructor ``` Foo bar = new Foo(); ``` And when and how should we use getInstance() (static factory methods) ``` Foo bar = Foo.getInstance(); ``` What is the difference between these two? I have always used a constructor, but when should I use `getInstance()` instead?