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.
原文：http://www.cnblogs.com/haokaibo/p/3561219.html