《Effective Java》

1、 避免使用终结函数

终结函数守卫者

 

public Class Foo {

        private final Object finalizerGuardian = new Object () {

               protected void finalize() throws Throwable {

            //  Finalize outer Foo object

        }

        }

}

 

2、 改写equals方法的通用约定

自反性     对称性    传递性    一致性    非空性

 

    public boolean equals(Object obj) {                // 一定要写Object，否则不是覆写的父类的方法

        if (this == obj) return true;                      // 提高比较性能

        if (!(obj instanceof MyType)) return false;      // 包含了null的判断

             

              MyType p = (MyType) obj;

             

              return p.x == x && p.y ==y

    }

 

3、 改写equals方法时总是要改写hashcode

 

如果根据equals方法相等，则hashcode一定要相等，这样就可以正确用作HashMap，HashSet和Hashtable

 

public int hashCode () {

        return 888;

}

 

       正确，但是退化成链表了。哈哈

 

（1）boolean        (f? 0: 1)

（2）byte,char,short或者int              (int)f

（3）long      （int）(f  ^  (f >>> 32))           或者 new Long(long).intVaue() 或者 % Integer.MAX_VALUE

（4）float      Float.floatToIntBits(f)

（5）double   Double.doubleToLongBits(f);

（6）object    hashcode, 如果为空，0

（7）array     递归调用（1）－（6）

        int result = 17

       result = 37*result + c1;

       result = 37*result + c2;

       result = 37*result + c3;

       return result;

 

4、 总是要改写toString

类名@hashcode码（如何不覆写，就是指针）

 

5、 非可变类,接口优于抽象类

 

6、 复合优于继承

   要么专门为继承设计，要么禁止继承

 

7、优先考虑静态成员类

 

8、 返回零长度的数组而不是null

 

9、 如果要求精确，避免使用float和double

   应使用BigDecimal或者int和long（自己控制小数点）

 

9、 如果其它类型更合适，避免使用字符串

   （1）字符串不适合代替类型安全枚举

public class Suit {

    private final String name;

    private Suit(String name) {this.name = name;}

 

    public static final Suit CLUBS = new Suit("clubs");

    public static final Suit CLUBS = new Suit("diamonds");

... ...

}

 

   （2）字符串不适合代替聚集类型

   （3）字符串不适合代替能力表

    ThreadLocal对象的设计

   （4）用StringBuffer代替多个字符串的连接操作

 

10、 重用常用的异常

 

        IllegalArgumentException                          参数的值不合适

        IllegalStateException                                 对象状态不合适

        NullPointerException                                空指针

        IndexOutOfBoundsException                     下标越界

        ConcurrentModificationException               并发修改

        UnsupportedOperationException                 不支持的操作

 

11、 努力使失败保存原子性

比如Stack的popup

 

12、迟缓初始化的双重检查模式

错误:

private static Foo foo = null;

 

public static Foo getFoo() {

if (foo==null) {

synchronized (Foo.class) {

if (foo ==null) {

foo = new Foo();

}

}

return foo;

}

 

有同步开销：

private static Foo foo = null;

 

public static synchronize Foo getFoo() {

if (foo == null)

foo = new Foo();

return foo;

}

 

比较好的方式：按需初始化容器类

private static class FooHolder{

static final Foo foo = new Foo();

}

 

public static Foo getFoo() {return FooHolder.foo;}

 

13、 使用wait方法的标准模式,永远不要在循环的外面调用wait

     synchronized (obj) {

        while (condition) {

               obj.wait

        }

       

        notifyAll();

}

 

14、 任何依赖于线程调度器而达到的正确性或性能要求，很有可能是不可移植的

 不要使用Thread.yield() 和 改变优先级

 

15、 避免使用线程组

   不安全，基本过时。

 

16、 保护性拷贝

Class MyDateObject {

    private final Date start;

    private final Date end;

 

    public MyDateObject (Date start,Date end) {

        this.start = start;

        this.end = end;

    }

}

 

（1）防止 传入参数start，end变化

    public MyDateObject (Date start,Date end) {

        this.start = new Date(start);

        this.end = new Date(end);

    }

（2）防止 内部参数变化

    public Date getStart() {

        return start.clone();

    }

 

17、 序列化

private final static long serialVersionUID = randomLongValue;

UID：保持兼容性

 

       允许子类实现Serializable或禁止子类实现Serializable两者之间的一个折中方案是，提供一个可访问的无参数构造函数。该方案允许（但不要求）子类实现Serializable。要自己在writeObject方法里面控制super里面的字段是否需要序列化。

 

transient

 

private void readObject(ObjectInputStream ois) {              //相当于构造函数

        ois.defaultReadObject();

    }

 

private void writeObject(ObjectOutputStream ois) {

       

}

 

private Object readSolve() {         //可以用来返回保护性拷贝，以及单态模式的唯一性控制

        return Object

}

 

private Object readSolve()