Static factory methods have several advantages over constructors for creating object instances, such as returning immutable objects or objects of subclasses. They allow returning an object of any subtype, have named methods instead of anonymous constructors, and can reduce verbosity for parameterized types. Some examples include Boolean.valueOf() and factory methods in the RandomGenerators class.

1. JAVA
CONSIDER STATIC FACTORY METHODS INSTEAD OF CONSTRUCTORS
Ye Win
11/21/2015

2. Contents
• Preface (Summary)
• Static Factory Methods
• Advantages
• Disadvantages
• Summary (Preface)

3. Preface (Summary)
In preface, static factory methods and public constructors both have
their uses, and it pays to understand their relative merits. Often static
factories are preferable, so avoid the reflex to provide public
constructors without first considering static factories.

4. Static Factory Methods
• 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.

5. Static Factory Methods
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;
}
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.

6. Advantages
First advantage of static factory methods is that, unlike
constructors, they have names.
• If the parameters to a constructor do not, in and of themselves,
describe the object being returned, a static factory with a well-chosen
name is easier to use and the resulting client code easier to read.
• Now let’s seen by an example.

7. Advantages
• Look at the following example.
• We have a RandomIntGenerator class that, as the name suggests,
generates random int numbers. Something like:
public class RandomIntGenerator {
private final int min;
private final int max;
public int next() {...}
}

8. Advantages
• Our generator takes a minimum and maximum and then generates
random numbers between those 2 values. Notice that the two
attributes are declared final so we have to initialize them either on
their declaration or in the class constructor. Let’s go with the
constructor:
public RandomIntGenerator(int min, int max) {
this.min = min;
this.max = max;
}

9. Advantages
• Now, we also want to give our clients the possibility to specify just a
minimum value and then generate random values between that
minimum and the max possible value for ints. So we add a second
constructor:
public RandomIntGenerator(int min) {
this.min = min;
this.max = Integer.MAX_VALUE;
}

10. Advantages
• So far so good, right? But in the same way that we provided a
constructor to just specify the minimum value, we want to do the
same for just the maximum. We’ll just add a third constructor like:
public RandomIntGenerator(int max) {
this.min = Integer.MIN_VALUE;
this.max = max;
}
• If you try that, you’ll get a compilation error that goes: Duplicate
method RandomIntGenerator(int) in type RandomIntGenerator.
What’s wrong?

11. Advantages
• Full script:
public class RandomIntGenerator {
private final int min;
private final int max;
public int next() {...}
public RandomIntGenerator(int min, int max) {
this.min = min;
this.max = max;
}
public RandomIntGenerator(int min) {
this.min = min;
this.max = Integer.MAX_VALUE;
}
/* Compilation error will be occurred. */
public RandomIntGenerator(int max) {
this.min = Integer.MIN_VALUE;
this.max = max;
}
}

12. Advantages
• The problem is that constructors, by definition, have no names. As
such, a class can only have one constructor with a given signature in
the same way that you can’t have two methods with the same
signature (same return type, name and parameters type).
• That is why when we tried to add the RandomIntGenerator(int
max) constructor we got that compilation error, because we already
had the RandomIntGenerator(int min) one.

13. Advantages
• Now let’s apply static factories to our RandomIntGenerator example, we could
get:
public class RandomIntGenerator {
private final int min;
private final int max;
// private constructor to non-institate class
private RandomIntGenerator(int min, int max) {
this.min = min;
this.max = max;
}
public static RandomIntGenerator between(int max, int min) {
return new RandomIntGenerator(min, max);
}
public static RandomIntGenerator biggerThan(int min) {
return new RandomIntGenerator(min, Integer.MAX_VALUE);
}
public static RandomIntGenerator smallerThan(int max) {
return new RandomIntGenerator(Integer.MIN_VALUE, max);
}
public int next() {...}
}

14. Advantages
• Note : How the constructor was made private to ensure that the
class is only instantiated through its public static factory methods.
• Also note how your intent is clearly expressed when you have a client
with RandomIntGenerator.between(10,20) instead of
new RandomIntGenerator(10,20)
• Point is clear, we replace the constructors with static factory methods
and carefully chosen names to highlight their differences.

15. Advantages
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.
This is extremely useful when working with immutable classes to
provide constant objects for common used values and avoid creating
unnecessary duplicate objects. (You can refer avoid creating uncessary objects in this link
http://www.slideshare.net/mysky14/avoid-creating-unncessary-objects)

16. Advantages
public static Boolean valueOf(boolean b) {
return b ? Boolean.TRUE : Boolean.FALSE;
}
• The Boolean.valueOf code that I showed previously illustrates this
point perfectly. Notice that this static method returns either TRUE
or FALSE, both immutable Boolean objects.
• This technique is similar to the Flyweight pattern (I am promise I will post about this
pattern in near future, please don’t forget to following me at slideshare.). It can greatly improve
performance if equivalent objects are requested often, especially if
they are expensive to create.

17. Advantages
A third advantage of static factory methods is that, unlike
constructors, they can return an object of any subtype of their return
type.
• This gives you great flexibility in choosing the class of the returned
object.
• Moreover, you can hide implementation classes and have an interface-
based API (I am promise I will post about this interface-based framework in near future, please don’t forget to following me at slideshare.),
which is usually a really good idea.
• But I think this can be better seen by an example.

18. Advantages
• Look at the following example.
• Imagine that we now want to provide random generators not just for
integers but for other data-types like String, Double or Long. They are
all going to have a next() method that returns a random object of a
particular type, so we could start with an interface like:
public interface RandomGenerator<T> {
T next();
}

19. Advantages
• Our first implementation of the RandomIntGenerator now becomes:
class RandomIntGenerator implements RandomGenerator<Integer> {
private final int min;
private final int max;
RandomIntGenerator(int min, int max) {
this.min = min;
this.max = max;
}
public Integer next() {...}
}

20. Advantages
• We could also have a String generator:
class RandomStringGenerator implements RandomGenerator<String>
{
private final String prefix;
RandomStringGenerator(String prefix) {
this.prefix = prefix;
}
public String next() {...}
}

21. Advantages
• Notice how all the classes are declared package-private (default scope) and so
are their constructors. This means that no client outside of their package can
create instances of these generators. So what do we do? Tip: It starts with
“static” and ends with “methods”. Consider the following class:
public final class RandomGenerators {
// Suppresses default constructor, ensuring non-instantiability.
private RandomGenerators() {}
public static final RandomGenerator<Integer> getIntGenerator() {
return new RandomIntGenerator(Integer.MIN_VALUE, Integer.MAX_VALUE);
}
public static final RandomGenerator<String> getStringGenerator() {
return new RandomStringGenerator("");
}
}

22. Advantages
• RandomGenerators is just a noninstantiable utility class with nothing
else than static factory methods. Being on the same package as the
different generators this class can effectively access and instantiate
those classes. But here comes the interesting part.
• Note that the methods only return the RandomGenerator interface,
and that’s all the clients need really.
• If they get a RandomGenerator<Integer> they know that they can
call next() and get a random integer.

23. Advantages
Not only can the class of an object returned by a public static factory
method be nonpublic, but the class can vary from invocation to
invocation depending on the values of the parameters to the static
factory.
Any class that is a subtype of the declared return type is permissible.
The class of the returned object can also vary from release to release
for enhanced software maintainability and performance.

24. Advantages
• A fourth advantage of static factory methods is that they reduce
the verbosity of creating parameterized type instances.
• Have you ever had to write code like this?
Map<String, List<String>> map = new HashMap<String,List<String>>();

25. Advantages
• You are repeating the same parameters twice on the same line of
code. Wouldn’t it be nice if the right side of the assign could
be inferred from the left side?
• Well, with static factories it can. The following code is taken from
Guava’s Maps class:
public static <K, V> HashMap<K, V> newHashMap() {
return new HashMap<K, V>();
}
• So now our client code becomes:
Map<String, List<String>> map = Maps.newHashMap();

26. Advantages
• Pretty nice, isn’t it? This capability is known as Type inference. It’s
worth mentioning that Java 7 introduced type inference through the
use of the diamond operator. So if you’re using Java 7 you can write
the previous example as:
Map<String, List<String>> map = new HashMap<>();
• Unfortunately, the standard collection implementations such as
HashMap do not have factory methods as of release 1.6, but you can
put these methods in your own utility class.
• More importantly, you can provide such static factories in your
own parameterized classes.

27. Disadvantages
The main disadvantage of static factories is that classes without
public or protected constructors cannot be extended. But this might
be actually a good thing in some cases because it encourages
developers to favor composition over inheritance. (I am promise I will post about this
interface-based framework in near future, please don’t forget to following me at slideshare.)
• The same is true for nonpublic classes returned by public static factories.
For example, it is impossible to subclass any of the convenience
implementation classes in the Collections Framework.
• But I think this can be better seen by an our own example.

28. Disadvantages
• Suppose you have a class called Person:
class Person {
public static Person createWithFirstName(String firstName) {
return new Person(firstName, null, null);
}
// etc. - more factory methods
// private constructor
private Person(String firstName, String lastName, String nickname) { }
// useful method
public String getDisplayName() { }
}

29. Disadvantages
• It's all good and dandy. But now you also need a class
called Programmer, and you suddenly realize the programmers
are persons too!
• But all of a sudden, you can't just
class Programmer extends Person { }
• since Person doesn't have any public constructors.
• You can’t not subclassed which are not have public or protected
constructor.

30. Summary (Preface)
• In summary, static factory methods and public constructors both have
their uses, and it pays to understand their relative merits. Often static
factories are preferable, so avoid the reflex to provide public
constructors without first considering static factories.

32. References
• Effective Java – 2nd Edition (Joshua Bloch)
• http://stackoverflow.com/questions/19733789/static-factory-
disadvantage-over-constructor
• https://jlordiales.wordpress.com/2012/12/26/static-factory-methods-
vs-traditional-constructors/