[JAVA] Effective JAVA - Item 1 : Consider static factory methods instead of constructor

The way for a class to allow a client to obtain an instance

1. public contructors

2. static factory method

 

From now on, let me explain why we have to consider static factory methods instead of constructors.

 

Advantage 1

Static factory methods have names(unlike constructors)

 

well-chosen name is good for

• Easier to use
• Resulting client code easier to read
• End up calling the wrong one by mistake

Advantage 2

Not required to create a new object each time they're invoked

• Avoid creating unneccessary duplicate objects
• Greatly improve performance if they are expensive to create

Advantage 3

Return an object of any subtype of their return type

• Reduce the conceptual weight
• Gave great flexibility in choosing the class of the returned object

Advantage 4

The returned object can vary from call to call as a function of the input parameters

• Any subtype of the declared return type is permissible

Advantage 5

The returned object need not exist when the class containing thr method is written

 

 

Caution

1. Static factory method is that classes without public or protected constructors cannot be subclassed
2. Hard for programmers to find

Common names for static factory methods

• from—A type-conversion method that takes a single parameter and returns a corresponding instance of this type, for example:

Date d = Date.from(instant);

 

• of—An aggregation method that takes multiple parameters and returns an instance of this type that incorporates them, for example: 

Set<Rank> faceCards = EnumSet.of(JACK, QUEEN, KING);

 

• valueOf—A more verbose alternative to from and of, for example:

BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);

 

• instance or getInstance—Returns an instance that is described by its parameters (if any) but cannot be said to have the same value, for example:

StackWalker luke = StackWalker.getInstance(options);

 

• create or newInstance—Like instance or getInstance, except that the method guarantees that each call returns a new instance, for example:

Object newArray = Array.newInstance(classObject, arrayLen);

 

• getType—Like getInstance, but used if the factory method is in a differentclass. Type is the type of object returned by the factory method, for example:

FileStore fs = Files.getFileStore(path);

 

• newType—Like newInstance, but used if the factory method is in a different class. Type is the type of object returned by the factory method, for example:

BufferedReader br = Files.newBufferedReader(path);

 

• type—A concise alternative to getType and newType, for example:

List<Complaint> litany = Collections.list(legacyLitany);