Effective java学习笔记

 

1．静态工厂方法代替构造函数

       如：public static Boolean valueOf(boolean){

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

}

一个类提供静态工厂方法的好处a.容易阅读，返回类型明确

                            b.调用时不一定非得产生一个新的对象

                            c.它可以返回一个原返回类型的子类型的对象，返回对象的类型是灵活性更大

                         缺点a.类如果不含共有的或受保护的构造函数，就不能被子类实例化

                              b.他们与普通静态方法没有什么区别。要想在文档中说明如何实例化一个类，是非常困难的。

例如java.util.Collections

2．使用私有构造函数强化singleton属性

     Public class single{

           Public static final single INSTANCE = new single();

           Private single(){}

}

 

Public class single2{

           private static final single2 INSTANCE = new single2();

           Private single2(){}

           Public static single2 getInstance(){

                   Return INSTANCE;

}

}

Single1的好处：组成类的成员的声明很清楚地表明了这个类是一个singleton：公有的静态域是final的，所以该域将总是包含相同的对象的引用。性能要好些

Single2的好处：灵活，在不改变API的前提下，允许我们改变想法，把类改成singleton或者不是singleton

3．通过私有构造函数强化不可实例化的能力

      Java.lang.Math  java.util.Arrays

4．避免重复创建对象

     String str = new String(“aaaa”);//Don’t do this

     String str = “aaa”;

   对于同时提供了静态工厂方法和构造函数的非可变类，优先选择静态工厂方法。避免每次调用都产生新的对象

Public class Person{

    Private final Date birthDate;

    Public Person(Date brthDate){

         this.birthDate = birthDate;

}

Public boolean isBadyBoomer(){

    Calender instance = Clender.getInstance(TimeZone.getTimeZone(“CMT”));

    Instance.set(1946,Calender.JANUARY,1,0,0,0);

   Date booleanStart  = instance.getTime();

   Instance.set(1965,Calender.JANUARY,1,0,0,0);

   Date booleanEnd = instance.getTime();

      Return  birthDate.compareTo(booleanStart)>=0&& birthDate.comareTo(booleanEnd) < 0

}

}

不要这样做，每次调用的时候都会实例化一次Calender

Public class Person{

    Private final Date birthDate;

    Public Person(Date brthDate){

         this.birthDate = birthDate;

}

Private static final Date BOOLEANSTART;

Private static final Date BOOLEANEND;

Static{

    Calender instance = Clender.getInstance(TimeZone.getTimeZone(“CMT”));

    Instance.set(1946,Calender.JANUARY,1,0,0,0);

   BOOLEANSTART  = instance.getTime();

   Instance.set(1965,Calender.JANUARY,1,0,0,0);

   BOOLEANEND = instance.getTime();

                         

}

 

Public boolean isBadyBoomer(){

Return birthDate.compareTo(BOOLEANSTART)>=0&& birthDate.comareTo(BOOLEANEND) < 0

}

}

5．消除过期对象引用

   如java.util.Stack的pop方法elementData[elementCount] = null;

6．避免使用终结函数

Finalizer

显示终止方法的例子InputStream和OutPutStream的close方法，java.util.Timer的cancel方法，显示终止方法通常与try—finally结合使用

7．改写equals的时候请遵守通用的约定

A．一个类的每个实例本质上都是唯一的。

B．不关心一个类是否提供了‘逻辑相等(logical equality)’的测试功能。例如java.util.Randomd的equals方法。

C．超类已经改写了equals方法。例如Set继承AbstractSet

,List—AbstactList,Map—AbstactMap

   D．一个私有的，包级私有的类。并且equals永远不会被调用

什么时候改写equals呢？当一个类有自己的‘逻辑相等’概念（不同于对象身份的概念），而且超类也没有改写equals以实现期望的行为

改写equals遵循的原则：

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 f alse，前提是对象上 equals 比较中所用的信息没有被修改。

对于任何非空引用值 x，x.equals(null) 都应返回 false。

高质量equals处方：

1．  使用= =操作符检查‘实参是否为指向对象的一个引用’，如果是的话放回true

2．  使用instanceof操作符检查‘实参是否为正确的类型

3．  把实参转换到正确的类型

4．  对于该类的每一个‘关键（significant）’域，检查实参中的域与当前对象中对应得域值是否匹配

Equals告诫：

1．  改写equals是，总是要改写hashCode

2．  不要让equals过于聪明

3．  不要使equals方法依赖不可靠的资源

4．  不要将equals声明的object对象替换为其他的类型例如：public Boolean equals(MyClasss 0){}这样其实是没有override。因为object.equals的实参是object类型。它是overload

8．改写equals是总要改写hashCode方法

    hashCode 的常规协定是：

在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。

如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。

以下情况不 是必需的：如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么在两个对象中的任一对象上调用 hashCode 方法必定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。

实际上，由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是 Java^TM编程语言不需要这种实现技巧。）

hashCode处方：

1.

把某个非零常数值，比如说1 7，保存在一个叫r e s u l t的i n t类型的变量中。

2. 对于对象中每一个关键域f（指e q u a l s方法中考虑的每一个域），完成以下步骤：

a. 为该域计算i n t类型的散列码c：

i. 如果该域是b o o l e a n类型，则计算(f ? 0 : 1)。

ii. 如果该域是b y t e、c h a r、s h o r t或者i n t类型，则计算( i n t ) f。

iii. 如果该域是l o n g类型，则计算(int)(f ^ (f >>> 32))。

i v. 如果该域是f l o a t类型，则计算F l o a t . f l o a t T o I n t B i t s( f )。

v. 如果该域是d o u b l e类型，则计算D o u b l e . d o u b l e T o L o n g Bits( f )得到一个l o n g类型的值，然后按照步骤2 . a . i i i，对该l o n g型值计算 散列值。

vi. 如果该域是一个对象引用，并且该类的e q u a l s方法通过递归调用e q u a l s的方式来比较这个域，则同样对这个域递归调用h a s h C o d e。如果要求一个更为复杂的比较，则为这个域计算一个“规范表示（canonical representation）”

，然后针对这个范式表示调用h a s h C o d e。如果这个域的值为n u l l ,则返回0（或者其他某个常数，但习惯上使用0）。

vii. 如果该域是一个数组，则把每一个元素当做单独的域来处理。也就是说，递归地应用上述规则，对每个重要的元素计算一个散列码，然后根据步骤2 . b中的做法把这些散列值组合起来。

b. 按照下面的公式，把步骤a中计算得到的散列码c组合到r e s u l t中：

   result = 37*result + c;

3．返回result

4．检查‘是否相等的实例具有相等的散列码’

9.总要改写toString方法

10.谨慎的改写clone方法

         如果一个类实现了cloneable，则object的clone方法返回该对象的逐域拷贝，否则。它抛出一个cloneNotSupportedException异常

    clone约定：

    创建并返回此对象的一个副本。“副本”的准确含义可能依赖于对象的类。一般来说，对于任何对象 x，如果表达式：

x.clone() != x是正确的，则表达式：

x.clone().getClass() == x.getClass()将为 true，但这些不是绝对条件。一般情况下是：

x.clone().equals(x)将为 true，但这不是绝对条件。

按照惯例，返回的对象应该通过调用 super.clone 获得。如果一个类及其所有的超类（Object 除外）都遵守此约定，则 x.clone().getClass() == x.getClass()。

 

按照惯例，此方法返回的对象应该独立于该对象（正被克隆的对象）。要获得此独立性，在 super.clone 返回对象之前，有必要对该对象的一个或多个字段进行修改。这通常意味着要复制包含正在被克隆对象的内部“深层结构”的所有可变对象，并使用对副本的引用替换对这些对象的引用。如果一个类只包含基本字段或对不变对象的引用，那么通常不需要修改 super.clone 返回的对象中的字段。

 

Object 类的 clone 方法执行特定的克隆操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException。注意：所有的数组都被视为实现接口 Cloneable。否则，此方法会创建此对象的类的一个新实例，并像通过分配那样，严格使用此对象相应字段的内容初始化该对象的所有字段；这些字段的内容没有被自我克隆。所以，此方法执行的是该对象的“浅表复制”，而不“深层复制”操作。

 

Object 类本身不实现接口 Cloneable，所以在类为 Object 的对象上调用 clone 方法将会导致在运行时抛出异常

11.考虑实现comparable接口

     CompareTo是java.lang.Comparable接口中的唯一对象

     Comparable的规范

     比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

在前面的描述中，符号 sgn(expression) 表示数学上的 signum 函数，该函数根据 expression 的值是负数、零还是正数，分别返回 -1、0 或 1。 实现类必须确保对于所有的 x 和 y，都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x))。（这意味着如果 y.compareTo(x) 抛出一个异常，则 x.compareTo(y) 也要抛出一个异常。）

 

实现类还必须确保关系是可传递的：(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0。

 

最后，实现程序必须确保 x.compareTo(y)==0 意味着对于所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。

 

强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法，但不是 严格要求这样做。一般来说，任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”

12.使类和成员的可访问能力最小化

   公有类不应该包含公有域---例外（final修饰的按照惯例大写，下划线分开）

13.支持非可变性

   一个非可变类是一个简单的类，它的实例不能被修改。每个实例中包含的所有信息都必须在该实例被创建的时候就提供出来，并且在对象的整个生存期（lifetime）内固定不变。例如String，原语类型的包装类，bigInteger，BigDecimal。非可变类更加易于设计，实现，使用，它们不容易出错，更加安全

   约束：

   a.不提供任何修改对象属性的方法（mutator）

   b.保证没有可被子类改写的方法

   c.使所有的域都是final的

   d.使所有的域都成为私有的（不提倡）

   e.保证对于任何可变组建的互斥访问---如果你的类具有指向可变对象的域，则必须确保该类的客户无法获得指向这些对象的引用。并且，永远不要客户提供的对象引用来初始化这样的域，也不要在任何一个访问方法中返回该对象的引用。在构造函数，访问方法和readObject方法中请使用保护性拷贝技术

 

   非可变类的缺点----对于每一个不同的值都要求一个独立的对象，创建这样的对象代价会很高

14.复合优于继承（inhertance）

    继承打破了封装性

15.要么专门为继承而设计，并给出文档说明，要么禁止继承

   构造函数一定不能调用可被改写的方法

16.接口优于继承类

已有的类可以很容易被更新，以实现新的接口。

接口是定义mixin（混合类型）的理想选择。一个混合类型是这样的：一个类除了实现它的‘基本类型（primary type）’之外，还可以实现这个mixin类型以表明它提供了某些可选择的行为

接口使得我们可以构造出非层次结构的类型框架。什么叫骨架实现类

17.接口只是被用于定义类型

   常量接口模式是对接口的不良使用

//Constant utility class

Public class PhysicalConstants{

    Rivate PhysicalConstants(){}

    Public static final double ELECTRON_MASS = 9.1000;

}

接口只是被用来定义类型的，它们不应该被用来导出常量

18.优先考虑静态成员类

嵌套类（nested class）是指被定义在另一个类的内部的类。嵌套类存在的目的应该只是为他外围类提供服务。如果一个嵌套类将来可能会用于其它的某个环境中，那么它应该是顶层类（top-level class）。嵌套类有四种：静态成员类（static member class），非静态成员类（nonstatic member class），匿名类（anonymous class）和局部类（local class）。出了第一种之外。其它三种都被称为内部类（inner class）

静态成员类是一种最简单的嵌套类。最好把它看成一个普通的类，只是碰巧被声明在另一个类的内部而已，它可以访问外围类的所有成员，包括哪些声明为私有的成语。

匿名类常见用法：1.创建一个函数对象—comparator实例

        Arrays.sort(args,new Comarator(){

              Public int comare(Object o1,Object o2){

                  Return ((String)o1).length() - ((String)o2).length();

}

});

2.创建一个过程对象，比如Thread，Runnable或者TimerTask实例

3.在一个静态工厂方法的内部

4.复杂的类型安全枚举类型

19.用类代替结构

20.用类层次来代替联合

21.用类代替enum结构

22.用类和接口来代替函数指针

23．检查参数的可用性

     例如索引必须是非负数，对象引用不能为null

24.需要时使用保护性拷贝

25.谨慎设计方法的原型

   谨慎选择方法的名字

   不要过于追求提供便利的方法

   避免长长的参数列表

   对于参数类型，优先使用接口而不是类

   谨慎使用函数对象

26.谨慎使用重载

27.返回零长度的数组而不是null

28.为所导出的api编写文档注释

29.将局部变量的作用域最小化

    for(int i=0;i< list.size();i++){

   doSomthing....

}

和

for(int i = 0; n = list.size();i<n;i++){

   doSommething;

}

下面一个效率要高一些

30.了解和使用库

31.如果需要精确的答案，请避免使用float和double

32.如果其他类型更合适，则尽量避免使用字符串

   字符串不适合代替其他的值类型

   字符串不适合代替枚举类型----类型安全枚举类型（typesafe enum）和int值比较适合

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

字符串不适合代替