Effective Java Role-1

最新推荐文章于 2024-07-14 00:26:17 发布

ctze5992

最新推荐文章于 2024-07-14 00:26:17 发布

阅读量93

点赞数

一。创建和销毁对象

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

实例代码：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。调用本地对象的时候，本地对象不拥有要害性资源的前提下，终止方法完成必要的工作以释放资源。