Advantage

• Unlike constructors, they have names. (BigInteger.probablePrime vs BigInteger(int, int, Random)
• They are not required to create a new object each time they're invoked(Flyweight pattern). This ensures that a.equals(b) if and only if a = = b. Then the client can use = = instead of equals method which gets better performance to Equals method.
• It can return an object of any subtype of their return type.(This gives you great flexibility in choosing the class of the returned object. )

  /********************sample code ******************/

  // Service provider framework sketch

  // Service interface

  public interface Service {

  ... // Service-specific methods go here

  }

  // Service provider interface

  public interface Provider {

  Service newService();

  }

  // Noninstantiable class for service registration and access

  public class Services {

  private Services() {

  } // Prevents instantiation (Item 4)

  // Maps service names to services

  private static final Map<String, Provider> providers = new ConcurrentHashMap<String, Provider>();

  public static final String DEFAULT_PROVIDER_NAME = "<def>";

  // Provider registration API

  public static void registerDefaultProvider(Provider p) {

  registerProvider(DEFAULT_PROVIDER_NAME, p);

  }

  public static void registerProvider(String name, Provider p) {

  providers.put(name, p);

  }

  // Service access API

  public static Service newInstance() {

  return newInstance(DEFAULT_PROVIDER_NAME);

  }

  public static Service newInstance(String name) {

  Provider p = providers.get(name);

  if (p == null)

  throw new IllegalArgumentException(

  "No provider registered with name: " + name);

  return p.newService();

  }

  }

• Reduce the verbosity of creating parameterized type instances.

• The class without public or protected constructors cannot be subclassed.
• They are not readily distinguishable from other static methods.

Here are some common names for static factory methods:

• valueOf—Returns an instance that has, loosely speaking, the same value as its

parameters. Such static factories are effectively type-conversion methods.

• of—A concise alternative to valueOf, popularized by EnumSet(Item 32).

• getInstance—Returns an instance that is described by the parameters but

cannot be said to have the same value. In the case of a singleton, getInstance

takes no parameters and returns the sole instance.

• newInstance—LikegetInstance, except that newInstanceguarantees that

each instance returned is distinct from all others.

• getType—Like getInstance, but used when the factory method is in a different class. Type indicates the type of object returned by the factory method.

• newType—Like newInstance, but used when the factory method is in a different class. Type indicates the type of object returned by the factory method.