Effective Java 读书笔记（一）：使用静态工厂方法代替构造器

这是Effective Java第2章提出的第一条建议：

考虑用静态工厂方法代替构造器

此处的静态工厂方法并不是设计模式，主要指static修饰的静态方法，关于static的说明可以参考之前的博文《java中final与static的使用场景总结》。

什么是静态工厂方法？

可以参考书中的例子（摘自JDK1.7 java.lang.Boolean）

public final class Boolean implements java.io.Serializable,

        Comparable<Boolean> {

    public static final Boolean TRUE = new Boolean(true);

    public static final Boolean FALSE = new Boolean(false);

    public static Boolean valueOf(boolean b) {

        return (b ? TRUE : FALSE);

    }

}

如果需要获取一个Boolean对象，常规的方法是new Boolean(true)，但是也可以如上图所示Boolean.valueOf(true)，这便是静态工厂方法。

静态工厂方法的优势

静态工厂方法与构造器不同的第一大优势在于，它们有名称。

使用构造函数构造对象时，我们需要通过文档仔细比对传递什么样的参数能够构造什么样的对象。但是静态工厂方法可以使用不同的方法名字使得其构造的对象更加明晰。我们完全可以通过方法名明白构造了什么样的对象。

例如下面的例子（摘自JDK1.7 java.math.BigInteger）

public class BigInteger extends Number implements Comparable<BigInteger> {

    /**

     * Returns a positive BigInteger that is probably prime, with the

     * specified bitLength. The probability that a BigInteger returned

     * by this method is composite does not exceed 2<sup>-100</sup>.

     */

    public static BigInteger probablePrime(int bitLength, Random rnd) {

       // XXX

    }

}

静态工厂方法与构造器不同的第二大优势在于，不必在每次调用它们的时候都创建一个新对象。

我们调用静态工厂方法返回的可能是缓存的一个对象，而不是新对象。可以进行重复利用，从而避免创建不必要的重复对象。
如果程序经常请求创建相同的对象，并且创建的代价很高，则静态工厂方法可以极大地提升性能。
前面提到的Boolean.valueOf(boolean)便说明了这项技术。

静态工厂方法与构造器不同的第三大优势在于，他们可以返回原返回类型的任何子类型的对象。

我们在选择返回对象的类时有了更大的灵活性。参见java.util.EnumSet，其本身被abstract修饰，无法直接调用其构造函数。但可以调用其静态方法noneOf来创建对象，并且根据参数返回合适的对象。

public abstract class EnumSet<E extends Enum<E>> extends AbstractSet<E>

    implements Cloneable, java.io.Serializable {

    EnumSet(Class<E>elementType, Enum[] universe) {

    }

    //RegularEnumSet与JumboEnumSet均为EnumSet的子类

    public static <E extends Enum<E>> EnumSet<E> noneOf(Class<E> elementType) {

        if (universe.length <= 64)

            return new RegularEnumSet<>(elementType, universe);

        else

            return new JumboEnumSet<>(elementType, universe);

    }

}

第四大优势在于，创建参数化类型实例的时候，可以使代码变得更加简洁。

例如对于HashMap的实例化：

//常规实例化方式

Map<String, List<String>> m =

    new HashMap<String, List<String>>();

public static <K, V> HashMap<K, V> newInstance() {

    return new HashMap<K, V>();

}

//使用静态工厂方法实例化，简化繁琐的声明

Map<String, List<String>> m = HashMap.newInstance();

静态工厂方法的劣势

类如果不含公有的或受保护的构造器，就不能被实例化。

如果我们在类中将构造函数设为private，只提供静态工厂方法来构建对象，那么我们将不能通过继承扩展该类。
但是这也会鼓励我们使用复合而不是继承来扩展类。

它们与其他的静态方法实际上没有任何区别。

在API文档中，构建对象的静态工厂方法并没有像构造器那样明确标识出来，不能和其他静态方法很方便地区分开来。
如果类中只提供静态工厂方法而不是构造器，要想查明如何实例化一个类将会变得困难。
我们可以通过遵循静态工厂方法的命名规范来弥补这一劣势：

valueOf - 返回的实例与它的参数具有相同的值，一般作为类型转换使用，例如Boolean.valueOf(boolean)
of - valueOf的更为简洁的替代。
getInstance - 返回的实例通过方法的参数来描述，但不能说与参数具有同样的值。对于Singleton来说，使用无参getInstance，返回唯一的实例。
newInstance - 像getInstance一样，但其能够确保每次都返回新的对象。
getType - 像getInstance一样，但此方法返回的对象是另一个不同的类。
newType - 像getType一样，但每次返回一个新对象。

总而言之，静态工厂方法和公有构造器具有各自的用处，但静态工厂方法通常更加合适，所以我们应该优先考虑静态工厂方法。