Effective Java-创建和销毁对象

本部分的内容是关于创建和销毁对象的。包括：
何时以及如何创建对象？
何时以及如何避免创建对象？
如何确保创建的对象能够适时地销毁？
内容导图如下：

创建和销毁对象

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.要采用安全的方式确保资源的回收。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,324评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,356评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,328评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,147评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,160评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,115评论 1赞 296
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,025评论 3赞 417
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,867评论 0赞 274
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,307评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,528评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,688评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,409评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,001评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,657评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,811评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,685评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,573评论 2赞 353

推荐阅读更多精彩内容

  • Effective Java：创建和销毁对象
    第1条：考虑用静态工厂方法代替构造器 （Consider static factory methods inste...
    Gino_Gu阅读 319评论 0赞 0
  • Effective Java——创建和销毁对象
    代码首先是给人看的，所以写代码要有写诗一样的感觉（哈哈雷军说的），无论是写逻辑、中间件或是写框架都是如此。想要写好...
    码农一颗颗阅读 674评论 0赞 1
  • Effective Java笔记一 创建和销毁对象
    Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参...
    圣骑士wind阅读 385评论 0赞 2
  • 清平调
    拙作一篇，君可喜欢？ 夜深人静月无光， 风卷残枝叶染黄。 路畔影稀人已散， 柳旁独饮饯别伤。
    残梦书生阅读 553评论 6赞 14
  • 作者的素质
    当下社会是网络时代，全民是作者，同时又都是读者。他们成色各异，为提高众人写作素质，望修养以下几点。 一、感情充沛。...
    风云翁阅读 1,065评论 7赞 23