1.

Consider StaticFactory methods instead of constructors

a.

Unlike constructors, we can provide meaningful names

b. Unlike constructors, they are not required to create new object each time they are
invoked.
c.

They can return any subtype of their return type. This technique leads to interface
based frameworks.

d. Reduces verbosity of creating parameterized type instances.

e.

Only static factory methods having no public/protected constructors cant be subclassed.

f.

Static factory methods are not readily distinguishable from other static methods
unless we follow proper naming conventions like(valueOf, of, getInstance,
newInstanace, getType, newType etc)

Service Provider framework:

There are three essential components in service provider framework.
1.

Service Interface: which providers implement

2. Provider Registration API: Which system uses to register implementations giving

clients access to them.
3.

Service Access API: Which clients use to obtain an instance of the service.

4. Service provider interface(optional): Which providers implement to create instance

of their service implementation.
Example: JDBC
a.

Service Interface : Connection

b. Provider Registration API: DriverManager.registerDrivers()

c.

Service Access API: DriverManager. getConnection()

d. Service Provider Interface: Driver

2.

Consider Builder when faced with many constructor parameters.

a.

Instead of making the desired object directly, the client calls the constructor or
static factory with required parameters and gets a builder object.

b. Then the client calls setters like methods to set the optional parameters based on
the interest.
c.

Finally client calls the parameter less build() method to generate the object.

Example:

NutritionFacts.java

3.

Enforce the singleton property with a private constructor or an enum type.

a.

Singleton is a class that is instantiated exactly once.

b. Making singleton can make it difficult to test its clients.

c.

There are two approaches public attribute with private constructor and public
factory method with private constructor.

d. The advantage of factorymethod approach is implementation details can be hidden.

e.

In case of a singleton class that is implementing serializable interface following

additional things to be taken care.
i. All the attributes should be made transient
ii. Implement readResolve method and return the same instance [in the below
example return INSTANCE

SingleTon.java

f.

From Java 1.5 onwards, we can use enums.

i. Example: public enum SingleTon{
INSTANCE;
Public getValue(){
//provide implementations.
}
}

The above enum approach is equivalent to public field approach. The additional benefit
is, it provides the serialization machinery for free.
Of all the approaches single element enum is the best way to implement a singleton.
4.

Enforce noninstantiability with a private constructor.

a.

Utility classes were not designed to be instantiated.

b. These classes need to have private constructors that throw AssertionError.

Throwing an error ensures that the constructor is not being invoked from within the
class.
c.
5.

AbstractClass and/or Final doesnt fully prevents us from instantiating the class.

Avoid creating unnecessary objects.

a.

Reuse can be faster and stylish. It is definitely applicable in case the object is
immutable. Ex. String str = new String(DO NOT DO THIS);

b. Consider using static factory methods instead of constructors. For example prefer
using Boolean.valueOf() to new Boolean();
c.

It is also valid for mutable objects where we are sure that created objects will
never be modified.

d. Heavy use of autoboxing causes performance issues

6.

Eliminate Obsolete Object references.

a.

Nulling the object references should be the exception rather than the norm.

b. The best way to eliminate an obsolete reference is to let the variable that contained
the reference fall out of scope. This occurs naturally if you define each variable in
the narrowest possible scope
c.

Generally speaking, whenever a class manages its own memory, the pro-grammer
should be alert for memory leaks.

d. Another common source of memory leaks is caches.

e.

7.

A third common source of memory leaks is listeners and other callbacks.

Avoid Finalizers.
a.

Finalizers are unpredictable, often dangerous, and generally un-necessary

b. There is a severe performance penalty for using finalizers.

Generics And Collections

1.

We shouldnt use raw types such as List.

2. using raw types can lead to exceptions at runtime, so dont use them in new code.