本部分的内容是关于创建和销毁对象的。包括：
何时以及如何创建对象？
何时以及如何避免创建对象？
如何确保创建的对象能够适时地销毁？
内容导图如下：
创建和销毁对象
1.考虑用静态工厂方法代替构造器
对于类而言，为了让客户端创建它自身的实例，通常就是提供公有的构造器，但在某些情况下，让类提供一个公有的静态工厂方法来返回类的实例可能更为合适。
public static Boolean valueOf(boolean b) {
return b ? Boolean.TRUE : Boolean.FALSE;
}
同构造器相比，静态工厂方法创建对象的优势有：
1）它们有名称
用方法名称来解释要创建的对象更易使用和阅读
//通过静态工厂方法来说明返回的可能为素数
public static BigInteger probablePrime(int bitLength, Random random) {
return new BigInteger(bitLength, 100, random);
}
2）不必在每次调用时都创建一个新对象
静态工厂方法能够为重复的调用返回相同的对象，避免产生多个不必要的实例
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);
}
3）可以返回原返回类型的任何子类型的对象
采用这种方法，可以构建基于接口的框架，另外，通过接口而非具体的实现来引用返回的对象，也是一种良好的面向接口编程习惯。
4）创建参数化类型实例的时候，使代码变得更加简洁
Map<String, List<String>> m = new HashMap<String, List<String>>();
public static <K, V> HashMap<K, V> newInstance() {
return new HashMap<K, V>();
}
关于类型推导，JDK1.7已经支持，目前的IDE也都支持此特性了。
缺点在于：
1）类如果不含有非私有的构造器，就不能被子类化
不提供public/protected构造器，类就不能被子类化。
2）它们与其他的静态方法没有任何区别，不够醒目
静态工厂方法没有在API文档中标识出来，会对使用带来一定不便。
静态工厂方法和公有构造器各有用处，需要理解它们各自的长处。静态工厂通常更加合适，切忌第一反应就是提供公有的构造器，而不先考虑静态工厂。
2.遇到多个构造器参数时要考虑用构造器
当构造器的参数有4个或者更多的时候，要考虑使用Builder模式。
当构造器参数较多的时候，程序员习惯采用重叠构造器模式来处理，如下述代码：
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public NutritionFacts(int servingSize, int servings) {
this(servingSize, servings, 0);
}
public NutritionFacts(int servingSize, int servings, int calories) {
this(servingSize, servings, calories, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat) {
this(servingSize, servings, calories, fat, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
this(servingSize, servings, calories, fat, sodium, 0);
}
public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
this.servingSize = servingSize;
this.servings = servings;
this.calories = calories;
this.fat = fat;
this.sodium = sodium;
this.carbohydrate = carbohydrate;
}
}
通过重叠构造器模式可行，但是当有许多参数的时候，客户端代码会很难编写，并且难以阅读。
另一种办法是采用JavaBeans模式，调用一个无参构造函数来创建对象，然后调用setter方法来设置每个必要的参数，以及每个相关的可选参数：
public class NutritionFacts {
private int servingSize = -1;
private int servings = -1;
private int calories = 0;
private int fat = 0;
private int sodium = 0;
private int carbohydrate = 0;
public NutritionFacts() {}
public void setServingSize(int val) {
servingSize = val;
}
public void setServings(int val) {
servings = val;
}
public void setCalories(int val) {
calories = val;
}
public void setFat(int val) {
fat = val;
}
public void setSodium(int val) {
sodium = val;
}
public void setCarbohydrate(int val) {
carbohydrate = val;
}
}
//创建实例
NutritionFacts cc = new NutritionFacts();
cc.setServingSize(240);
cc.setServings(8);
cc.setCalories(100);
cc.setSodium(35);
cc.setCarbohydrate(27);
通过JavaBeans模式创建实例很容易，代码也容易阅读，但它有个严重的缺点：构造过程被分到了几个调用中，在构造过程中JavaBeans可能处于不一致的状态。另外，它阻止了把类当作不可变的可能，需要程序员采取额外的处理来确保它的线程安全性。
还有一种方法就是通过Builder模式来构建对象实例，既能像重叠构造器模式那样安全，也能像JavaBeans模式那么易读。
public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;
public static class Builder {
private final int servingSize;
private final int servings;
private int calories = 0;
private int fat = 0;
private int carbohydrate = 0;
private int sodium = 0;
public Builder(int servingSize, int serbings) {
this.servingSize = servingSize;
this.servings = serbings;
}
public Builder calories(int val) {
calories = val;
return this;
}
public Builder fat(int val) {
fat = val;
return this;
}
public Builder carbohydrate(int val) {
carbohydrate = val;
return this;
}
public Builder sodium(int val) {
sodium = val;
return this;
}
public NutritionFacts build() {
return new NutritionFacts(this);
}
}
private NutritionFacts(Builder builder) {
servingSize = builder.servingSize;
servings = builder.servings;
calories = builder.calories;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
}
Builder模式模拟了具名的可选参数，代码容易编写，也易于阅读，它还可以对参数强加约束条件。当构造多参数的对象实例时，是一种非常不错的选择。
如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder模式就是种不错的选择，特别是当大多数参数都是可选的时候。与传统的重叠构造器模式相比，使用Builder模式的客户端代码更易于阅读和编写，也比JavaBeans更加安全。
3.用私有构造器或者枚举类型强化Singleton属性
通过私有化构造器来实现单例模式
//通过公有域来实现单例
public class Elvis {
public static final Elvis INSTANCE = new Elvis();
private Elvis() {...}
public void leaveTheBuilding() {...}
}
//通过静态工厂方法来实现单例
public class Elvis {
private static final Elvis INSTANCE = new Elvis();
private Elvis() {...}
public static Elvis getInstance() {
return INSTANCE;
}
public void leaveTheBuilding() {...}
}
//通过单元素的枚举类来实现单例
public enum Elvis {
INSTANCE;
public void leaveTheBuilding() {...}
}
单元素的枚举类型无偿地提供了序列化的机制，也可以绝对防止多次实例化，是实现Singleton的最佳方法。
4.通过私有构造器强化不可实例化的能力
某些工具类可能只包含静态方法和静态域，实例化它们没有任何意义，为防止用户实例化这些类，可将构造器声明为private。
public class UtilityClass {
private UtilityClass() {
throw new AssertionError();
}
...
}
这种用法的副作用就是：它使得一个类不能被子类化。
5.避免创建不必要的对象
通常来说，如果对象可以重用，最好就不要创建新的对象。如果对象是不可变的，它就始终可以被重用，如字符串常量。
//始终创建新对象
String s = new String("Java");
//重用不可变对象
String s = "Java";
如果可变对象在使用的过程中始终不会被修改，也是可以重用的。
public class Person {
private final Date birthDate;
public boolean isBabyBoomer() {
Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
Date boomStart = gmtCal.getTime();
gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
Date boomEnd = gmtCal.getTime();
return birthDate.compareTo(boomStart) >= 0 && birthDate.compareTo(boomEnd) < 0;
}
}
采用上面的方式，每当isBabyBoomer()被调用的时候，都会新建一个Calendar、一个TimeZone和两个Date实例，这是不必要的。优化如下：
public class Person {
private final Date birthDate;
private static final Date BOOM_START;
private static final Date BOOM_END;
static {
Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
BOOM_START = gmtCal.getTime();
gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
BOOM_END = gmtCal.getTime();
}
public boolean isBabyBoomer() {
return birthDate.compareTo(BOOM_START) >= 0 && birthDate.compareTo(BOOM_END) < 0;
}
}
改进后的代码不仅语义更加清晰，在isBabyBoomer(）被频繁调用的情况下，也会显著地提高程序的性能。
基本类型和装箱基本类型是有区别的，使用的时候要当心无意识的自动装箱。下例中将long写成Long，虽然能得到正确结果，但计算过程中构造了大约231个多余的Long实例。
public static void main(String[] args) {
Long sum = 0L;
for(long i = 0; i < Integer.MAX_VALUE; i++) {
sum += i;
}
System.out.println(sum);
}
应该重用现有对象的时候，就不要创建新的对象。
6.消除过期的对象引用
消除过期引用最好的办法是让包含该引用的变量结束其生命周期。
以下三种情况容易被忽视，从而造成内存泄露：
（1）类有自己管理的内存，要警惕内存泄露问题
（2）缓存
（3）监听器和回调
//Stack自身管理元素存储的内存，实现时要警惕内存泄露
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
elements = new Object[DEFAULT_INITIAL_CAPACITY];
}
public void push(Object e) {
ensureCapacity();
elements[size++] = e;
}
public Object pop() {
if(size == 0) {
throw new EmptyStackException();
}
return elements[--size];
}
private void ensureCapacity() {
if(elements.length == size) {
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
//上述pop方法有隐含的内存泄露
public Object pop() {
if(size == 0) {
throw new EmptyStackException();
}
Object result = elements[--size];
elements[size] = null;
return result;
}
最好是在内存泄露之前就知道如何预测此类问题，并阻止它们发生。
7.避免使用终结方法
终结方法(finalizer)通常是不可预测的，它不能保证会被及时地执行，利用它来回收资源是非常危险的。
Java语言规范不保证终结方法会被及时地执行，也不保证它们一定会被执行。不应该依赖终结方法来更新重要的持久状态。
另外，终结方法会造成非常严重的性能损失。
如果类中封装的资源（例如文件或线程）确实需要终止，可以提供一个显式的终止方法。显式的终止方法通常与try-finally结合使用，以确保及时终止。
Foo foo = new Foo(...);
try {
// do something
...
} finally {
//调用显式终止方法回收资源
foo.terminate();
}
1.通过new Constructor()来构造对象只是创建实例的一种方式，具体如何构建对象实例更好，还要依据使用对象的目的，根据使用场景来分别对待。
2.Java虽有GC机制可以自动回收垃圾，但如果使用不当，依然会造成内存泄露，要清楚所创建对象的生命周期，必要时需手动清空对象引用。
3.要采用安全的方式确保资源的回收。
网友评论