《Effective Java》学习笔记

核心提示： 这本书对于java程序员的意义就如《Effective C++》对于C++程序员的意义一样，我想是每个java爱好者的必读书之一了，《Effective Java》学习笔记，最近在啃这本书，一些学习笔记希望能对大家有所帮助，调用本地对象的时候，本地对象不拥有要害性资源的前提下，一，创建和销毁对象第一条：考虑用静态工

  这本书对于java程序员的意义就如《Effective C++》对于C++程序员的意义一样，我想是每个java爱好者的必读书之一了，最近在啃这本书，一些学习笔记希望能对大家有所帮助。

一。创建和销毁对象

第一条：考虑用静态工厂方法代替构造函数

实例代码 ：Boolean类中的valueOf()方法

  public static Boolean valueOf(boolean b)

 {

　　  return (b?Boolean.TRUE:Boolean.FALSE);

  }

优点：

1。和构造函数不同，静态工厂方法有自己的名字。假如存在着多种版本的构造函数，有的仅仅是参数顺便的不同，此时你应该考虑用静态工厂方法。

2。静态工厂方法不要求一定要创建对象。可使用预先构造好的对象。例如Boolean.valueOf()方法就从不创建对象。在需要频繁创建对象，并且创建对象成本较高的情况下，你应该考虑采用静态工厂方法

3。与构造函数不同，静态工厂方法可以返回一个原返回类型的子类型的对象。这方面的最好的例子就是Collections Framework。Collections Framework有20个实用的集合接口实现，这些实现大多数是通过一个不可实例子化的java.utl.Collections中的静态工厂方法导出的。

缺点：

1。类假如不含有公有或者受保护的构造函数，就不能被继续。某种意义上这也限制了继续的滥用

2。静态工厂方法和其他静态方法一样，一般要在API文档中作出非凡的说明。在没有强烈的需要下，你还是应该使用规范的构造函数。



第2条：使用私有构造函数强化singleton属性

  所谓singleton是指这样的类，它只能被实例化一次/（也就是单例模式），有两种方式，如下：

1。提供一个静态常量

public class Example{

　 public static final Example INSTANCE=new Example();

　 PRivate Example(){　　 //构造函数为私有

　 ...}

　 ....

}

2。使用静态工厂方法

public class Example{

　 private static final Example INSTANCE=new Example();//改为私有

　 private Example(){　　 //构造函数为私有

　 ...}

　 public static Example getInstance(){

　　　 return INSTANCE;

　  }　

....

}

第一种方法在性能上可能更好，第2种方法提供了更大的灵活性，你可以决定是否做成singleton。要使一个singleton的类变成可序列化的，仅仅实现Serializable接口是不够，还必须提供一个readResolve()方法，否则会产生一个新的实例。违反了singleton的本意

　  private Object readResolve() throws ObjectStreamException{

　　　  return INSTANCE;

　　  }



第3条。通过私有构造函数强化不可实例能力

　  也就是不使某个类不能产生任何对象。或者你要说写成抽象类不就可以了？NO,抽象类可以被实现，其子类也可以被实现。我们要的是绝对不能被实例化的类，这种类一般只有一些静态变量和静态方法，只是作为工具类使用，如java.utl.Arrays。要做到这一点只要包含一个私有的显式构造函数。这样同时也保证了这个类不能被继续，因为子类无法访问父类的构造函数。



第4条：避免重复创建对象

  假如一个对象是非可变的，那么它总可以被重用，而不是再去创建一个对象。例如

String s=new String("denny")；

  里面的"denny"本身就是一个实例。而这句话每次又重新创建一个同样的实例。这完全是没有必要的，假如在一个频繁调用的方法中使用这样的语句，性能上会有很大影响。应该用

String s="denny";来代替上面的语句。一个常用的方法是把重复需要用到的对象做成类的私有的静态常量（当然，要保证这些变量在创建以后不再改变），用一个static块包含他们。另外，不要以为创建对象是代价非常昂贵，相反，一些小对象的构造函数往往只做很少的工作，所以小对象的创建是非常廉价的，只有重量级的对象（如数据库连接）才需要采用对象池来重用对象。

第5条：消除过期引用

  “内存泄露”！什么，我有没有听错，java也有“内存泄露”。是的，那不是C++的专利。看下面的例子

　  public Class Stack{

　　　  private Object[] elements;

　　　  private in size=0;

　　　  public Stack(int initialCapacity){

　　　　　　　　　 this.elements=new Object[initialCapacity];

　　　　}

　　　  public Object pop()

　　　  {

　　　　　　　  if(size==0)

　　　　　　　　　 throw new EmptyStackException();

　　　　　　　  return elements[--size];

　　　 }

　　　　 ....

　 } 这个程序并没有很明显的错误，但是随着不断增加的内存占用，程序的性能的降低会逐渐显现。原因在于这个栈收缩的时候，从栈中弹出的对象并不会被当作垃圾回收，这是因为栈内部维持着这些对象的过期引用，也就是永远也不会再被解除的引用，应该把pop操作修改下：

　 public Object pop()

　　　  {

　　　　　　　  if(size==0)

　　　　　　　　　 throw new EmptyStackException();

　　　　　　　　 Object result=elements[--size];

　　　　　　　　  elements[size]==null;  //把引用设为null

　　　　　　　　  return result;

　　　 }

自己治理内存的类一般都存在着这样的问题，必须时刻警惕。内存泄露的另一个来源就是缓存了，你缓存了一个对象，却忘记了去释放。内存泄露问题可以通过专门的工具来检测。

第6条：避免使用终结函数（finalize())

　  想起一次在CSDN论坛上，有人问什么时候该使用finlize()，和C++有什么不同，我竟然回答说可以在finalize()方法中处理一些关闭资源的操作（关闭文件等等）。汗颜！终结函数并不能保证会被及时地执行，从一个对象变的不可到达（通过对象网络没有了这个对象的引用），到它的终结函数被执行，这段时间的长短是任意的，不确定的。所以，时间要害的任务不应该由终结函数来完成，例如关闭一个已经被打开的文件。由于JVM延迟执行终结函数，所以大量的文件保留在打开状态！而且终结函数的实现是不同的JVM中有不同的方法，所以你不能保证此函数的移植性。记住这点：

　  我们不应该依靠一个终结函数来更新要害性的永久状态。

那么我们该如何编程序来执行清理工作，通常提供一个显式的终止方法，通常与tr..finally结构结合使用，这方面的例子最好的是java.io里面的各种流操作了，基本都有一个close()方法，你必须显式地关闭打开的资源。终结函数的使用有两个合理的方面：

1。充当最后一道“安全网”，在客户端忘记或者不能调用显式终止方法的时候。

2。调用本地对象的时候，本地对象不拥有要害性资源的前提下，终止方法完成必要的工作以释放资源。