effective java读书小记（一）创建和销毁对象
- 序言
《effective java》可谓是java学习者心中的一本绝对不能不拜读的好书，她对于目标读者（有一点编程基础和开发经验）的人来说，由浅入深，言简意赅。每一章节都分为若干的条目，完全可以利用平时的零碎时间片来阅读和思考。仅仅是阅读了第二章，创建和销毁对象，从静态工厂、构造器等基础得不能再基础的知识，却使我有一种特别的感觉，就如同见到一位会使我怦然心动的女生，那种惊喜，是那么的美妙，却也是那么的震撼。原来女生还能够如此地美，原来书，所谓让人头晕的编程类书籍，可以写得如此地好，直击心灵，让人有相见恨晚的感觉。正如我在朋友圈写到的，阅书如品茗，品酒，如人生。她完全不同于《21天精通xxoo》的粗制滥造，也不像《Think in java》一样对于谁都高不可攀（我读起来有丝丝的苦涩）。
好了说太多了，现在开始正文吧。
更多精彩，请关注：http://muscle1990.com/?p=295
- 创建和销毁对象
本章主题是讲述创建和销毁对象，何时以及如何创建，何时以及如何销毁对象，如何确保他们能够适时读销毁，，以及如何管理对象销毁之前必须进行的各种清理工作。
- 第一条：考虑用静态工厂
我们先来看看这个静态工厂方法，返回累的实例：
public static Boolean valueOf(boolean b){
return b?Boolean.TRUE:Boolean.FALSE;
}
通过调用该方法，就可以非常方便地利用工厂得到实例。
静态工厂和构造器不同的优势在于：
- 她们有名称，as what you can see。
- 不需要每次调用他们的时候都创建一个新的对象。
- 她们可以灵活地返回原类型的任何子类型对象。
- 在创建参数化实例的时候，她使得代码变得更加的简洁。
for example：
在我们使用带参构造器创建一个map时，需要这样：
Map<String,String> stringMap=new HashMap<String,String>();
但是，假设HashMap提供以下静态工厂：
public static <K,V> HashMap<K,V> newInstance(){
return new HashMap<K,V>();
}
那么我们在创建map的时候，就可以这样写了：
Map<String,String> stringMap =HashMap.newInstance();
倘若你在工作中常需要做创建对象的事，会不会有一丝的惊喜呢？
- 第二条：遇到多个构造器参数时需要考虑使用构建器：
静态工厂和构造器有个共同的局限性，都不能很好地扩增到大量可选属性。
考虑一个人的资料，有些是必须要的，如Id，name，有些是可选的，如地区、身高，体重等。
方法一，带参构造器
package new_and_destory_object;
/*
* @author 莫仕豪
* moshihao@gmail.com muscle1990.com
* @version:2013-7-31 下午9:53:36
*
*/
public class Person {
private String id;//必选
private String name;//必选
private int height;//可选
private int weight;//可选
//private xxx ooo;//可选
//and so on...//可选
public Person(String id,String name){
this.id=id;
this.name=name;
}
public Person(String id,String name,int height){
this.id=id;
this.name=name;
this.height=height;
}
public Person(String id,String name,int height,int weight){
this.id=id;
this.name=name;
this.height=height;
this.weight=weight;
}
public Person(String id,String name,int height,int weight,xxx ooo,...){
this.id=id;
this.name=name;
this.height=height;
this.weight=weight;
...
}
}
然而，在我们创建对象的时候，就会这样：
Person Muscle=new Person("helloworld","Muscle",172,55,........);
如果有很多属性呢？我参与的实际项目中，遇到过超过150个属性的。使用构造器设参方法，难道我需要写上百个？再慢慢选？慢慢填数据？再save？oh my god！
方法二：javaBean setter 模式
package new_and_destory_object;
/*
* @author 莫仕豪
* moshihao@gmail.com muscle1990.com
* @version:2013-7-31 下午9:53:36
*
*/
public class Person {
private String id;//必选
private String name;//必选
private int height;//可选
private int weight;//可选
//private xxx ooo;//可选
//and so on...//可选
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
//...
}
这种方法深信大家也不会陌生，然而，同样的情况，属性多呢。。。
Person Muscle = new Person();
Muscle.setId("helloworld");
...
除此之外，因为构造过程被分到几次的调用，所以javaBean会产生不一致的可能状态。
方法三：builder模式
幸运的是，还有第三种替代方法，既能够保持像重叠构造器那样安全，又能像javaBean那样易读灵活。
package new_and_destory_object;
/*
* @author 莫仕豪
* moshihao@gmail.com muscle1990.com
* @version:2013-7-31 下午9:53:36
*
*/
public class Person {
private String id;// 必选
private String name;// 必选
private int height;// 可选
private int weight;// 可选
// and so on...
public static class Builder {
// 必选属性
private final String id;
private final String name;
// 可选
private int height =0;
private int weight =0;
// and so on...
public Builder(String id,String name){
this.id=id;
this.name=name;
}
public Builder height(int height){
this.height=height;
return this;
}
public Builder weight(int weight){
this.weight=weight;
return this;
}
// and so on...
public Person build(){
return new Person(this);
}
}
public Person(Builder builder) {
id =builder.id;
name =builder.name;
height =builder.height;
weight =builder.weight;
}
}
注意Person是不可变的。下面的创建对象的实现：
Person Muscle = new Person.Builder("helloworld","Muscle").height(173).weight(55).build();
这样的代码，就会变得非常容易编写，并且简洁易懂。
- 第三条：用私有构造器或者枚举类型强化单例属性。
public class Singleton{ private static final Singleton INSTANCE =new Singleton(); private Singleton(){...} public static Singleton getInstance(){return INSTANCE;} }
这部分暂时没多大感觉，单例用得比较少，不过也学习了。
- 第四条：通过私有构造器，强化不可实例化的能力。
这个讲得不错，在HSBC Gltc的Interview的时候有问到。
- 第五条：避免创建不必要的对象
这部分写得特别受用，不多说，来码：
String s=new String("String");//永远不要这样写代码，求你了
赋值的String已经为对象实例，这样就是等于多了一个实例，如果是在比较频繁的String操作，这样会产生成千上万无用的实例。
String s="String";//这样就可以了，简洁明了不浪费
还需要将可重用的重用，正如同书中例子一样，起点时间，终点时间设为static final，这样就可以了，完全没有必要每一次调用都实例化。
装箱拆箱问题：
public static void main(String args[]){
//需要拆箱时间：16s
//基本类型时间：2s
Long sum =0L;
for(long i=0;i<Integer.MAX_VALUE;i++){
sum +=1;
}
System.out.println(sum);
}
倘若你还不知道Long和long的区别的话，简单点说就是Long是对象，long是基本类型，他们转换需要装箱拆箱。而效率从上可见一般，优先使用基本类型，不要手滑写错类型。。。
- 第六条：
消除过期对象引用
package new_and_destory_object;
import java.util.Arrays;
import java.util.EmptyStackException;
/*
* @author 莫仕豪
* moshihao@gmail.com muscle1990.com
* @version:2013-7-31 下午11:13:52
*
*/
public class Stack {
public Object[] elements;
private int size =0;
private static final int DEFAULT_ININAL_CAPACITY =16;
public Stack(){
elements=new Object[DEFAULT_ININAL_CAPACITY];
}
public void push(Object e){
ensureCapacity();
elements[size++]=e;
}
public Object pop(){
if(0==size){
throw new EmptyStackException();}
return elements[--size];
}
private void ensureCapacity() {
if(elements.length == size){
elements =Arrays.copyOf(elements, 2 *size+1);
}
}
}
因为栈会维护对象的过期引用，了解JVM内存管理的应该明白，有引用的对象，就算明知道是垃圾，一样不会回收。所以这段代码就算运行没有一点问题，但是会有导致内存溢出的风险。
我们需要修改弹出栈的操作：
public Object pop(){
if(0==size){
throw new EmptyStackException();
}
Object result =elements[--size];
elements[size] =null;
return result;
}
一般而言，只要是类自己管理内存，我们就需要警惕内存泄漏的发生。
除此之外，我们还需要注意，内存泄漏的另一个常见的来源是缓存。一旦你把对象放到缓存中，就很容易被淡忘。
- 第七条：避免使用终结方法：
老实说，没用过，但是了解一下也是好的
- 结言：
effective java读书小记（一）创建和销毁对象，这篇读书笔记连想带码，用了差不多两个小时的时间，很久没有这样写过读书笔记了，学海无涯，书山有路，加油！
Muscle Mo 2013.7.31.晚写于大学城宿舍
