Effective Java Item01 - Consider static factory methods instead of constructors

• 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.
• Disadvantages
  • 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.

Effective Java Item01 - Consider static factory methods instead of constructors

原文：http://www.cnblogs.com/haokaibo/p/3561219.html