Consider Static Factory Methods instead
of Constructors


The normal way for a client to obtain an
instance of itself is to provide a public constructor. But apart from this
there is another technique which should be the part of every programmer’s
toolkit. A class can provide a static factory method, which is static method
which returns the instance of the class.


Example :


The below method
translates a boolean primitive value into Boolean object reference.


public static Boolean valueOf(boolean b){

    return b ? Boolean.TRUE :



Note :

A class can have
static factory method instead of, or in addition to, constructors.


Advantages of using
static factory methods :


1. Unlike
Constructors, static factory methods 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. For example, the constructor BigInteger(int, int, Random), which
returns a BigInteger that is probably prime, would have been better expressed
as a static factory method named  BigInteger.probablePrime.


2. Static factory
method do not require to create a new object each time they are invoked :


This allows immutable classes to use
preconstructed instances, or to cache instances as they are constructed as to
avoid creating unnecessary duplicate objects. The Boolen.valueOf(boolean)
method illustrates this technique; it never creates an object. This can greatly
improve performance.



3. Static factory
methods can return an object of any subtype of their return type :


This gives us the flexibility of
choosing the class of the returned object. To understand the above advantage
better let’s take an example :

The class java.util.EnumSet introduced
in 1.5 release, has no public constructor, but only static factories. They
return one of the two implementations depending upon the size of the underlying
enum type; if it has 64 or fewer elements, the static factories return
RegularEnumSet instance, which is backed by single long; if enum type had 64 or
more elements, the factories return JumboEnumSet instance, backed by a long


4. Static factory
methods reduce the verbosity of creating the parameterized type instances :


Unfortunately, we must specify the type
parameters when we invoke the constructor of a parameterized class even if they
are obvious from context. This makes us provide the type parameters twice in
quick succession :


Example :


Map<String, List<String>> m=
new HashMap<String, List<String>>


This redundant specification quickly
becomes painful as the length and complexity of the type parameter increase.
But with static factories, the compiler can figure out the type parameters for
us. This is called type inference. For example,


public static <K, V> HashMap<K,
V> newInstance(){

return new HashMap<K, V>();



The above statement can reduce the
verbosity :

Map<String, List<String>>

Give some Likes to Authors


Support, help community and write on social network.