Effective Java

1. 创建和销毁对象

1) 考虑用静态工厂方法代替构造函数

   对于一个类，获得它的实例最常用的方法是提供一个共有的构造函数。但是有时候我们也可以为这个类提供一个简单的静态工厂方法(static factory method)。

   静态工厂方法可以比构造方法更为清楚的表达要创建的类的意义，它每次被调用的时候，不要求非要创建一个新的对象，它还可以返回一个原返回类型的子类型对象。

    有两个静态方法的名字已经非常流行了：
  1.valueOf：该方法返回的实例与它的参数具有同样的值。使用这个名字的静态工厂方法是一些非常有效的类型转换操作符。

  2.getInstance：返回的实例是由方法的参数来描述的，对于singleton的情形，该方法返回唯一的实例。

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

    Singleton类指只能实例化一次。Singleton通常用来代表那些本质上具有唯一性的系统组件。
     实现Singleton有两种方法。这两种方法都是把构造函数保持为私有，并且提供一个静态成员，以便允许客户能够访问该类的唯一实例。
4.方法

1) 检查参数的有效性

          对于共有的方法，使用javadoc@throws标签可以使文档记录下”一旦针对参数值的限制被违反之后将会抛出的异常”，典型情况下，这样的异常为IllegalArgumentException，IndexOutOfBoundsException，NullPointerException。

2) 需要时进行保护性拷贝

3) 谨慎设计方法的原型

         谨慎选择方法的名字
         不要过于追求提供便利的方法
         避免过长的参数列
         对于参数类型，优先使用接口而不是类
         谨慎地使用函数对象

4) 谨慎的使用重载

         重载方法的选择是静态的，而对于被改写的而方法的选择是动态的。

         一个安全二保守的策略是：永远不要导出两个具有相同参数数目的重载方法。


5) 返回0长度的数组

          好像我都是返回null

6) 为所有导出的API元素编写文档注释

          为了正确地编写API文档，你必须在每一个被导出的类、接口、构造函数、方法和域声明之前增加一个文档注释。

5.通用程序设计

1) 将局部变量的作用于最小化

          使一个局部变量的作用域最小化，最有力的技术是在第一次使用它的地方声明
几乎每一个局部变量的而声明都应该包含一个初始化表达式


2) 了解和使用库

          在每一个主要的JDK发行版本中，都会有许多新特性被加入到库中，所以与这些库保持同步是值得的。每一个程序员都应该熟悉lang，util等包其他库可以在需要的时候学习


3) 如果要精确的答案，避免使用float和double

          Float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，他们没有提供完全精确的结果，所以不应该用于要求精确结果的场合。特别是对于货币计算尤其不合适。如果希望系统处理十进制小数点，那么可以使用BifDecimal。

4) 如果其他类型适合，则尽量避免使用字符串


5) 了操作解字符串连接的性能

          字符串连接操作(+)是把多个字符串合并为一个字符串的便利途径。要想产生一行输出，或者构造一个字符串来表示一个小的、大小固定的对象，使用连接操作符是非常合适的，但是她不适合规模比较大的情形。为连接n个字符串而重复地使用字符串操作符，要求n的平方级的时间。这是由于字符串是非可变的，当两个字符串被连接时，他们的内容都要被拷贝。

    可以考虑使用StringBuilder

6) 通过接口引用对象

          List sss=new Vector();
          Vector sss=new Vector();

          上面两种应该使用前者更加合适。应该优先使用接口而不是类来引用对象。如果有合适的接口在，那么参数。返回值、变量和域的声明都应该使用接口类型。


7) 接口优于映像机制

          在使用映射机制的时候，你损失了编译时类型检查的好处，要求执行映像访问的代码非常笨拙，性能上也会有损失。

          通常普通应用程序在运行时刻不应该以映像方式访问对象。

8) 谨慎使用本地方法

         自从1.3发行版本的推出，使用本地方法来提高性能的做法已经不值得提倡。

9) 谨慎进行优化

          不要轻易的进行优化，在优化之前一定要对性能进行测量。应该努力编写最好的程序而不是最快的程序。

10) 遵循普遍接受的命名惯例


6.异常(在此贴出一篇http://www.iteye.com/topic/2038?page=1)

1) 只针对不正常的条件才使用异常

          异常只应该被用于不正常的条件，它们永远不应该用于正常的控制流。

2) 对于可恢复的条件使用被检查异常，对于程序错误使用运行时异常

3) 避免不必要的使用被检查的异常

          最被常用的异常是IllegalArgumentException

4) 尽量使用标准的异常

          高层的实现应该捕获底层的异常，同时抛出一个可以按照高层抽象进行解释的异常。

5) 抛出的异常要适合相应的抽象

6) 每个方法抛出的异常都要有文档

7) 在细节消息中包含失败-捕获信息

     为了捕获失败，一个异常的字符串表示应该包含所有”对该异常有贡献”
的参数个域的值。

8) 努力使失败保持原子性

          一个失败的方法调用应该使对象保持”它在被调用之前的状态”

9) 不要忽略异常

     Try{

     }catch(Exceptione ){
     }

     空的catch块会使异常达不到应有的目的，至少catch块应该包含一条条说明，用来解释为什么忽略掉这个异常。

7.线程


1) 对共享可变数据的同步访问

     Synchronized关键字可以保证在同一时刻，再有一个线程在执行一条语句。正确的使用同步可以保证其他任何方法都不会看到对象处于不一致的状态中。

2) 避免过多的同步

     在同步区域内应该做尽量少的工作。


3) 永远不要在循环的外面调用wait


4) 不要依赖于线程调度器

          任何依赖于线程调度桥而达到正确性货性能要求的程序，很有可能是不可移植的，线程优先级是Java平台上最不可移植的特征了。对于大多数程序员来说，Thread.yield的唯一用途是在测试间认为地增加一个程序的并发性。

5) 线程安全性的文档化


6) 避免使用线程组

          线程组基本上已经过时了


8.序列化

1) 谨慎的实现

          实现Serializable而付出的最大代价是，一旦一个类被发布，则”改变这个类的实现”的灵活性将大大降低。
          同时它增加了一错误和安全漏洞的可能性，随着一个类的新版本的发行，相关的测试负担增加了。


2) 考虑使用自定义的序列化形式

3) 保护性地编写readObject方法

4) 必要时提供一个readResolve方法


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

     有些情况下，可能会编写出只包含静态方法和静态域的类。这样的类不希望被实例化，但是缺少显示构造函数的情况下，编译器会自动提供一个共有的，无参 的默认构造函数。

     如果这个类允许其他应用程序new语句构造它的实例，但不允许拥有子类，那么就把类申明为final类型。
     如果一个类既不允许其他应用程序鼓噪它的实例，又不允许拥有子类，那么把构造方法声明为private类型。

4) 避免创建重复的对象

     重复使用同一个对象，而不是每次需要的时候就创建一个功能上等价的新对象，通常前者更为合适。
对于提供了静态工厂方法和构造函数的非可变类，可以利用静态工厂方法而不是构造函数，以避免创建重复的对象。比如Boolean.valueOf(String)

5) 消除过期对象的引用

     一般而言，只要一个类管理自己它的内存，程序员就应该警惕内存泄露问题。一旦一个元素被释放，则该元素中的对象引用应该被清空。

6) 避免使用终结函数

     我们不应该依赖一个终结函数来更新关键性的永久状态。System.gc和System
.runFinalization并不保证终结函数一定会被执行。通常，我们需要提供一个显示的终止方法，既try  Finally结合

2. 对于所有对象都通用的方法

1) 改写equals的时候遵守通用约定


     在改写equals方法的时候应该遵循：
          自反性
          对称性
          传递性
          一致性

3) 改写equals时总是要改写hashCode

     在每个改写equals方法的类中，必须也要改写hashCode方法，相等的对象必须具有相等的散列码

4) 总要改写toString

     提供一些好的toStirng实现，可以试一个类表达的更加清楚的信息

5) 谨慎地改写clone

     所有实现了Cloneable接口的类都应该有一个共有的方法改写clone，比共有方法先调用super.clone。然后修正任何需要的域

6) 考虑实现Comparable接口

3.类和接口

1) 使类和成员的可访问能力最小化

     一个设计良好的模块会隐藏所有实现的细节，把它的API与实现清晰隔离起来，它可以有效地接触一个系统中个模块的耦合关系，使得这邪恶模块可以被独立的开发测试。
应该尽可能使每一个类或成员不被外界访问

2) 支持非可变性

     为了使一个类成为非可变类，要遵循一下几条原则
     1. 不要提供任何会修改对象的方法
     2. 保证没有可被子类改写的方法
     3. 使所有的域都是final
     4. 使所有域都是私有的
     5. 保证对于任何可变数组的互斥访问。如果你的类具有指向可变对象的域，则必须确保该类的客户无法获得指向这些对象的引用。

     即使你不能将一个类做成非可变类，那么你任然应该尽可能地限制它的可变性。

3) 复合优先于继承

     与方法调用不同的是，继承打破了封装性，会照成一系列令人难以置信的问题，作者提到了一个非常形象的HashSet的add和addAll的例子。避免这些问题，可以不扩展已有的类，而是在新的类中增加一个私有域，它引用了这个已有类的实例，这种设计称为复合，新类中的每个实例方法都是=可以调用被包含的已有实例中对应的方法，并返回它的结果。

     只有当子类真正是超类时的”子类型”时，继承才是合适的。

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

5) 接口优于抽象类

     已有的类和容易被更新，以实现新的接口。
     接口是定义混合类型的理想选择
     接口使得我们可以构造出非层次结构的类型框架
     接口使得安全地增加一个类成为可能

6) 接口只被用于定义类型

     有一种接口被称为常量接口，这样的接口没有包含任何方法，它只包含静态的final域，每个域都导出一个常量。这种模式是对接口的不良使用。一个类要在内部使用某些常量，这纯粹是实现细节。

7) 优先考虑静态成员类