第2条：遇到多个构造器参数时要考虑用构建器   

    某个类的属性较多，初始化的时候又有一些是必须初始化的，而且类型有形同，  

    比如new Contact("姓名","显示名","手机号","飞信号","所在地",年龄,性别);   

    前5个属性是String 类型，后2个是int类型，在填写构造方法的时候很容易填写错位，或者少填写，或者颠倒了属性，   

    如下方法可以减少这种错误发生的几率，   

 
  
  1. Contact contact = new Contact();     
  2.     contact.setName("姓名");     
  3.     contact.setDisplayName("显示名");     
  4.     contact.setPhoneNumber("手机号");     
  5.     contact.setFetionNumber("飞信号");     
  6.     contact.setHometown("所在地");     
  7.     contact.setAge(23);     
  8.     contact.setGender(0);     
 
  
这么写是通常的做法，看起来还不够清晰，我们在每个set方法里retrun一个Contact类型，比如
 
  
 
  
  1. public Contact setName(String name)     
  2.    {     
  3.        this.name = name;     
  4.        return this;     
  5.    }    
 
  
这样上面的构造Contact的代码就可以这么写了
 
  
 
  
  1. Contact contact = new Contact() .setName("姓名")     
  2.                                     .setDisplayName("显示名")     
  3.                                     .setPhoneNumber("手机号")     
  4.                                     .setFetionNumber("飞信号")     
  5.                                     .setHometown("所在地")     
  6.                                     .setAge(23)     
  7.                                     .setGender(0);    
 
  
 
 
  
    这样写是不是更清爽了！属性不会再填写错误了！而且阅读代码的时候也一目了然，都给Contact初始化了那些属性，和属性的值是什么！   
 
  
第3条：用私有构造器或者枚举类型强化Singleton属性   
 
  
 建议使用如下方法创建单例类   
 
  
 
 
  
 
  
  1. public final class Elvis     
  2.     {     
  3.         private static Elvis INSTANCE;     
  4.         private Elvis(){};     
  5.         synchronized public static Elvis getInstance()     
  6.         {     
  7.             if( INSTANCE == null )     
  8.             {     
  9.                 INSTANCE = new Elvis();     
  10.             }     
  11.             return INSTANCE;     
  12.         }     
  13.         //执行其他操作     
  14.         private Object readResolve()     
  15.         {     
  16.             return INSTANCE;     
  17.         }     
  18.     }    
     这种构建方法好处，组成类的成员声明很清楚地表明了这个类是个Singleton，并且也解决了INSTANCE的同步问题，    
  
    没有暴露共有的INSTANCE变量，这样更有力于隐藏类的内部实现，   
 
  
    另外，改做法也很容易就可以修改成非单例模式，加上的readResolve方法可以保证反序列化时也是同一个对象。   
 
  
     
 
  
第4条：通过私有构造器强化不可实例化的能力   
 
  
    我们软件中常用的常量集(Constants)，工具集(Tool,Utility)都应该是不可实例化的类，那么他们应该如下构建   
 
  
 
  
  1. public final class Constants     
  2.     {     
  3.         private Constants()     
  4.         {     
  5.             throw new AssertionError();     
  6.         }     
  7.         //其他常量的定义，或者静态方法的实现；     
  8.     }    
 
  
这样可以防止被继承，被实例化。   
 
  
       
 
  
第5条：避免创建不必要的对象   
 
  
    创建一个String对象，最佳方式如下
 
  
 
  
  1. String str = "初始化值";     
  2.     如果一个String在创建的时候我们不确定他的值，建议如下创建     
  3.     String str = "";     
  4.     强烈反对     
  5.     String str = null;     
  6.     这种写法，因为会有NullPointerException这个异常的危险，另外主要还有潜在隐患，比如做了如下操作     
  7.     str += "ABC";     
  8.     那么str = nullABC;了这个不是想要的结果。     
  9.     str = "";的初始化方式也有他的不足之处，在判断str是否有效的时候就要多加一个长度的判断如下     
  10.     if( str==null||str.length()<=0 ){}    
 
  
因为str的长度初始为0。   
        
     对于JDK1.5以后的版本有自动封装，自动拆装的功能，所以要尽量使用基本类型，尤其是长整型因为long 和Long很容易看差，而影响效率。   
     总之，要吝啬使用new操作符，他不仅会增加对象的数目，而且也给垃圾回收造成麻烦，还有潜在的内存泄漏风险，另外new操作也比较耗时。   
        
 第13条：使类和成员的可访问性最小化   
 第14条：在共有类中使用访问方法而非共有域   
     public的权限太大了，建议使用包级私有权限，也就是缺省（default）的访问级别。这样可以增加软件的防御性，public的变量应该杜绝使用，   
     可以使用get,set方法代替。这样可以不隐蔽数据域，也方便以后修改数据域。   
        
 第16条：复合优先于继承   
 第17条：要么为继承而设计，并提供文档说明，要么就禁止继承   
     继承不便于扩展，耦合性很大，继承打破了封装，因为基类向子类暴露了实现细节，基类的内部细节通常对子类是可见的，建议继承只限定在包内使用，   
     否则是非常危险的，对软件的防御行也有很大的破坏作用。   
     当父类的实现改变时可能要相应的对子类做出改变，也不能在运行时改变由父类继承来的实现。