CSDN博客

img dengbo

《Effective Java》读书笔记

发表于2004/7/3 16:38:00  855人阅读

分类: Java

http://blog.csdn.net/mingjava/archive/2004/06/26/27309.aspx

http://blog.csdn.net/mingjava/archive/2004/06/27/27880.aspx

http://blog.csdn.net/mingjava/archive/2004/06/30/31070.aspx

 

 

      终于翻开这本James都称赞的java经典书籍了,发现比一般的英语书籍要难懂一些。但是里面的Item都是非常实用的,是java程序员应该理解的。

Creating and Destroying Object

Item 1:考虑用静态工厂方法替代构造器
例如:public static Boolean valueOf(boolean b)
            {
                  return (b?Boolean.TRUE:Boolean.FALSE);
            }
这样的好处是方法有名字,并且它可以复用对象,不像构造器每次调用都产生新的对象。其次它还可以返回返回类型的子类。不好的地方是如果没有public or protected构造器的类将不能被继承。还有就是静态工厂方法的名字和其他的静态方法名字不容易区分。

Item 2:通过添加私有构造器来加强单例属性(singletom property)
例如:public class Hello
            {
                  private static final Hello Instance = new Hell();

                  private Hello()
                  {}
                    
                    public static Hello getInstance()
                      {
                     return Instance;

                     }
            }
这个私有构造器只能在内部被使用,确保了单例模式!
Item 3:避免创建重复的对象
对不可修改的对象尽量进行复用,这样效率和性能都会提高。例如如果循环100次String s = new String("hello")将创建100个对象 循环100次String s = "hello";则只创建了一个对象。很好的进行了复用。

Item 4:用私有构造器来避免被实例化

例如public UtilityClass
{
   private UtilityClass()
{}

///
}
通常那些工具类是这么设计的

Item 5:消除绝对的对象引用

      虽然java中使用gc来管理内存,但是如果不注意的话也会产生“内存泄漏”。例如下面的程序
public class Stack
{
 private Object[] elements;
 private int size = 0;
 
 public Stack(int i)
 {
  this.elements = new Object[i]; 
 } 
 
 public void push(Object e)
 {
  ensure();
  elements[size++] = e; 
 }
 
 public Object pop()
 {
  if(size == 0)
  {
   //// 
  } 
  
  return elements[size--];
 }
 
 private void ensure()
 {
  //// 
 }
}
标记的地方存在着内存泄漏的问题,因为当他被弹出栈的时候,它也没有成为可回收的垃圾对象,Stack维护着他们的绝对的引用。将不能更改。改进的方法是如下的写法
 public Object pop()
 {
  if(size == 0)
  {
   //// 
  } 
  Object obj = elements[--size];
  elements[size] = null;
  
  return obj;
 }
 但是切忌不要滥用null。

Item 6:避免finalizers
垃圾回收器是低线程级别运行的且不能被强迫执行。推荐使用的方法类似于
InputStream is = null;

try
{
      is = /////;
}
finally
{
      is.close();
}

Methods Common to All Objects

 

item 7:当你覆盖equals方法的时候一定要遵守general contact

 

   覆盖equals的时候一定要加倍的小心,其实最好的办法就是不覆盖这个方法。比如在下面的情况下就可以不覆盖

   1这个类的每个实例都是唯一的,例如Thread

   2 如果你不关心这个类是否该提供一个测试逻辑相等的方法

   3超类已经覆盖了equals方法,并且它合适子类使用

   4如果这个类是private或者是package-private的,并且你确信他不会被调用

 

   但是当我们要为这个类提供区分逻辑相等和引用相等的方法的时候,我们就必须要覆盖这个方法了。例如String类,Date类等,覆盖的时候我们一定要遵从general contact,说白了就是一个合同。合同的主要内容是

   1x.equals(x)必须返回true

   2x.equalsy)当且仅当y.equals(x)返回true的时候返回true

   3x.equals(y)返回truey.equals(z)返回true,那么x.equals(z)必须返回true

   4.如果没有任何修改得话 那么多次调用x.equals(y)的返回值应该不变

   5.任何时候非空的对象x,x.equals(null)必须返回false

下面是作者的建议如何正确的覆盖equals方法

1.  ==检查是否参数就是这个对象的引用

2.  instanceof判断参数的类型是否正确

3.  把参数转换成合适的类型

4.  比较类的字段是不是匹配

例如:

public boolean equals(Object o)

{

       if(o== this) return true;

       if(!(o instanceof xxxx) return false;

       xxx in = (xxx)o;

       return ……..

}

最后一点要注意的时候不要提供这样的方法public boolean equals(MyClass o)这样是重载并不是覆盖Objectequals方法

item 8 :当你覆盖equals的时候必须覆盖hashCode方法

   这点必须切忌,不然在你和hash-based集合打交道的时候,错误就会出现了。关键问题在于一定要满足相等的对象必须要有相等的hashCode。如果你在PhoneNumber类中覆盖了equals方法,但是没有覆盖hashCode方法,那么当你做如下操作的时候就会出现问题了。

Map m = new HashMap();

m.put(new PhoneNumber(408,863,3334),”ming”)
当你调用m.get(new PhoneNumber(408,863,3334))的时候你希望得到ming但是你却得到了null,为什么呢因为在整个过程中有两个PhoneNumber的实例,一个是put一个是get,但是他们两个逻辑相等的实例却得到不同的hashCode那么怎么可以取得以前存入的ming呢。

 

Item 9:永远覆盖toString方法

ObjecttoString方法返回的形式是Class的类型加上@加上16进制的hashcode。你最好在自己的类中提供toString方法更好的表述实例的信息,不然别人怎么看得明白呢。

 

Item 10:覆盖clone()方法的时候一定要小心

一个对象要想被Clone,那么要实现Clone()接口,这个接口没有定义任何的方法,但是如果你不实现这个接口的话,调用clone方法的时候会出现CloneNotSupportedException,这就是作者叫做mixin的接口类型。通常clone()方法可以这样覆盖

public Object clone()

{

try
{

              return super.clone();

}

catch(CloneNotSupportedException e)
{}

}

但是当你要clone的类里面含有可修改的引用字段的时候,那么你一定要把整个类的蓝图进行复制,如果对你clone得到的对象进行修改的时候还会影响到原来的实例,那么这是不可取的。所以应该这样clone()

public Object clone() throws CloneNotSupportedException

{

       Stack Result  = (Stack)super.clone();

       Result.elements = (Object[])elements.clone();

       Return result;

}

其中elementsstack类中可修改的引用字段,注意如果elementsfinal的话我们就无能为力了,因为不能给他重新赋值了.其实如果不是必须的话,根本就不用它最好。

 

Item 11:考虑适当的时候覆盖Comparable接口

       Thinking in java上说的更清楚,这里不多少了。

 

 

     越来越发现这是一本难得的好书,Java程序员不看这本书的话真是很遗憾。本章讲述的是类和接口相关的问题。这几个Item都非常重要.

Item 12:把类和成员的可访问范围降到最低

      好的模块设计应该尽最大可能封装好自己的内部信息,这样可以把模块之间的耦合程度降到最低。开发得以并行,无疑这将加快开发的速度,便于系统地维护。Java中通过访问控制符来解决这个问题。

  1. public表示这个类在任何范围都可用。
  2. protected表示只有子类和包内的类可以使用
  3. private-package(default)表示在包内可用
  4. private表示只有类内才可以用

你在设计一个类的时候应该尽量的按照4321得顺序设计。如果一个类只是被另一个类使用,那么应该考虑把它设计成这个类的内部类。通常public的类不应该有public得字段,不过我们通常会用一个类来定义所有的常量,这是允许的。不过必须保证这些字段要么是基本数据类型要么引用指向的对象是不可修改的。不然他们将可能被修改。例如下面的定义中data就是不合理的,后面两个没有问题。
public class Con
{
      public static final int[] data = {1,2,3};// it is bad
      public static final String hello = "world";
      public static final int i = 1;
}

Item 13:不可修改的类更受青睐

      不可修改的类意思是他们一经创建就不会改变,例如String类。他们的设计、实现都很方便,安全性高——它们是线程安全的。设计不可修改类有几点规则:

  1. 不要提供任何可以修改对象的方法
  2. 确保没有方法能够被覆盖,可以通过把它声明为final
  3. 所有字段设计成final
  4. 所有字段设计成private
  5. 确保外部不能访问到类的可修改的组件
    不可修改类也有个缺点就是创建不同值得类的时候要创建不同的对象,String就是这样的。通常有个解决的办法就是提供一个帮助类来弥补,例如StringBuffer类。

Item 14:化合比继承更值得考虑

      实现代码重用最重要的办法就是继承,但是继承破坏了封装,导致软件的键壮性不足。如果子类继承了父类,那么它从父类继承的方法就依赖父类的实现,一旦他改变了会导致不可预测的结果。作者介绍了InstrumentedHashSet作为反例进行说明,原因就是没有明白父类的方法实现。作者给出的解决办法是通过化合来代替继承,用包装类和转发方法来解决问题。把想扩展的类作为本类的一个private final得成员变量。把方法参数传递给这个成员变量并得到返回值。这样做的缺点是这样的类不适合回掉框架。继承虽然好,我们却不应该滥用,只有我们能确定它们之间是is-a得关系的时候才使用。

Item 15:如果要用继承那么设计以及文档都要有质量保证,否则就不要用它

      为了避免继承带来的问题,你必须提供精确的文档来说明覆盖相关方法可能出现的问题。在构造器内千万不要调用可以被覆盖的方法,因为子类覆盖方法的时候会出现问题。
import java.util.*;

public class SubClass extends SuperClass
{
 private final Date date;
 
 public SubClass()
 {
  date = new Date(); 
 }
 
 public void m()
 {
  System.out.println(date); 
 }
 
 public static void main(String[] args)
 {
  SubClass s = new SubClass();
  s.m(); 
 }
 
}

class SuperClass
{
 public SuperClass()
 {
  m(); 
 } 
 
 public void m()
 {
  
 }
}
由于在date被初始化之前super()已经被调用了,所以第一次输出null而不是当前的时间。
由于在Clone()或者序列化的时候非常类似构造器的功能,因此readObject()和clone()方法内最好也不要包括能被覆盖的方法。

Item 16:在接口和抽象类之间优先选择前者

      接口和抽象类都用来实现多态,不过我们应该优先考虑用接口。知道吗?James说过如果要让他重新设计java的话他会把所有都设计成接口的。抽象类的优点是方便扩展,因为它是被继承的,并且方法可以在抽象类内实现,接口则不行。

Item 17:接口只应该用来定义类型

      接口可以这样用的 Collection c = new xxxx();这是我们最常用的。不要把接口用来做其他的事情,比如常量的定义。你应该定义一个类,里面包含public final static 得字段。

Item 18: 在静态和非静态内部类之间选择前者

      如果一个类被定义在其他的类内部那么它就是嵌套类,可以分为静态内部类、非静态内部类和匿名类。
   static member class 得目的是为enclosing class服务,如果还有其他的目的,就应该把它设计成top-level class。nonstatic member class是和enclosing class instance关联的,如果不需要访问enclosing class instance的话应该把它设计成static得,不然会浪费时间和空间。anonymous class是声明和初始化同时进行的。可以放在代码的任意位置。典型应用是Listener 和process object例如Thread。


0 0

相关博文

我的热门文章

img
取 消
img