Effective Java 第二版读书笔记

【本文对许久前转载的部分过时博文进行了替换，所以发表时间可以不参考】

        本篇学习笔记为通读Effective Java 第二版后总结的主要篇幅，不涉及太多繁冗的描述性内容，在此补充一下。对规则的具体应用场景，可结合使用时的具体情况灵活而定，适合的才是最好的，以下为主要描述：
NO.1、考虑用静态工厂方法代替构造函数，即通过工厂方法获得实例而非 new ()
（1）好处
       有名字方便调用，不像诸多构造器，调用时不知道选哪一个
       BigDecimal.getInstanceFromString(...)
       可单例，不创建新实例
       可以返回任何子类型，方法中可做任何事情，返回任意类型。
       代码更简洁

Map> m= new HashMap>();
-->
public static  HashMap newInstance(){
       return new HashMap();
}
Map> m= HashMap.newInstance()

（2）总结
       方法名尽量采用valueOf、of、getInstance、newInstance、getType、newType
       与构造方式各有长处，灵活使用
NO.2、遇到多个构造器参数时要考虑构造器
       此时采用Builder方式（尤其是当大多数参数时可选时）替代重叠构造器、JavaBean方式，既能保证重叠构造器那样的安全性，也能保证JavaBeans模式那么好的可读性：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // 必输参数
        private final int servingSize;
        private final int servings;

        // 可选参数 - 初始化成默认值
        private int calories      = 0;
        private int fat           = 0;
        private int carbohydrate  = 0;
        private int sodium        = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val)
            { calories = val;      return this; }
        public Builder fat(int val)
            { fat = val;           return this; }
        public Builder carbohydrate(int val)
            { carbohydrate = val;  return this; }
        public Builder sodium(int val)
            { sodium = val;        return this; }
             
              // 构造产品
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
      
    // 构造器需要一个builder对象
    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola = new NutritionFacts.Builder(240,.
            calories(100).sodium(35).carbohydrate(27).build();
    }
}

NO.3、用私有的构造函数或枚举强化Singleton可靠性
示例：

 

/**
 * 普通的Singletone实现。
 */  
class TestSingleton1 {  
  private static final TestSingleton1 INSTANCE = new TestSingleton1();  
  public static TestSingleton1 getInstance() {  
    return INSTANCE;  
  }  
  private TestSingleton1() {  
  }  
}  
/**
 * 异常强化了的Singletone实现。
 */  
class TestSingleton2 {  
  private static final TestSingleton2 INSTANCE = new TestSingleton2();  
  public static TestSingleton2 getInstance() {  
    return INSTANCE;  
  }  
  private static boolean initSign;  
  private TestSingleton2() {  
    if (initSign) {  
      throw new RuntimeException("实例只能建造一次");  
    }  
    initSign = true;  
  }  
}  
/**
 * 枚举实现的Singleton，最安全
 */  
enum TestSingleton3 {  
  INSTANCE;  
  public static TestSingleton3 getInstance() {  
    return INSTANCE;  
  }
}

NO.4、通过私有构造器避免实例化
       私有构造器不能实例化，即便插入异常或反射也不会实例化，当然也不能被继承

 

public class TestPrivateConstruct {  
  public static void main(String[] args) {  
    new TestPrivateConstruct();  
  }  
  // 禁止任何类调用这个构造器  
  private TestPrivateConstruct() {  
    throw new AssertionError();  
  }  
}  

NO.5、避免创建不必要的、重复的对象
       尽可能地避免创建对象，而不是不创建对象（也不符合OO的思想）

 

×String s = new String("test");
√String s = "test";
×Boolean(String)
√Boolean.vauleOf(String)
public Set keySet() {
√  Set ks = keySet; //存储到keySet成员域
    return (ks != null ? ks : (keySet = new KeySet()));
}

       优先使用基本类型而非装操作：

 

public static void main(String[] args) {
×     Long sum = 0L;
√     long sum = 0L;
       for (long i = 0; i < Integer.MAX_VALUE; i++) {
              sum += i;
       }
       System.out.println(sum);
}

       对于确定了的对象，尽量只执行一次实例化，采用static、成员变量等等方式。

 

public boolean isBabyBoomer() {
×    //实例化对象
}
static {
√    //实例化对象
}
public boolean isBabyBoomer() {
      //
}

NO.6、消除过期的对象引用
       虽然JAVA提供了垃圾回收器对不可达对象的内存进行自动回收，但已分配且不再使用的对象却长期占用内存造成内存泄露，
       因为GC不会回收这些对象。主要关注：过期引用、缓存两种情况，其中缓存类可借助：WeakHashMap、WeakReference、软引用等方式进行，也可手动进行管理。

 

×return elements[--size]; //过期元素没有回收
  Object result =elements[--size];
√elements[size] = null;//只要外界不再引用即可回收
  return result; 

       消除过期引用最好的方法是让引用结束其任命周期，如在小的作用域内退出后自动结束就没有必要，可借助Heap Profiler进行内存泄露的分析。
NO.7、避免使用终结
       尽量不用类的finalizer()，除非忘了对象显示回收或用来回收不关键的本地资源时，因该方法线程的优先级很低，不能保证会被及时执行（执行时机不确定），JVM也总会延迟终结函数的执行。即便是System.gc和System.runFinalization，也不能保证终结立即执行，终结方法创建和销毁对象相对更慢。
       急需回收对象，可以使用tyr—finally。
NO.8、在改写equals方法时请遵守通用约定
       不需要override equals时就不要去麻烦，需要改写equals方法时，严格遵守约定，避免一些运行中未知的问题出现，规范如下：
       1、自反性，即x.equals(x)为true
       2、对称性，即当且仅当x.equals(y)为true时y.equals(x)也一定为true
       3、传递性，即对任意的x,y,z，如果x.equals(y)为true，并且y.equals(z)也为true,那么x.equals(z)也必须为true
       4、一致性，即对于任意的x,y，如果x,y都没有被修改的话，那么多次调用x.equals(y)要么一致地返回ture，要么一致地返回false
       5、对于非空的引用x，x.equals(null)一定要返回false

       其中：
       1、用==操作符检查实参是否为指向对象的同一个引用。
       2、使用instanceOf检查实参是否是正确的类型。
       3、instanceof之后，把实参转换成正确的类型。
       4、检查实参的域与当前对象的域值是否相等。
       5、编写完equals方法后，检查是否满足等价关系。

 

    public boolean equals(Object o)
    {
           if(o== this) return true;
           if(!(o instanceof xxxx) return false;
           xxx in = (xxx)o;
           return ……..
    }

       equals过程：
       避免事务处理过多
       避免不安全的依赖
       避免转换为其他类型
NO.9、覆盖equals时总是要覆盖hashCode
       否则违反Object.hashCode约定，导致该类无法结合所有基于散列的集合一起正常动作，这些集合包括HashMap、HashSet、Hashtable等，如没有覆盖hashCode方法而进行以下操作：
       Map m = new HashMap();
       m.put(new PhoneNumber(408,863,3334),"xujian")
       当调get(new PhoneNumber(408,863,3334))时得到null，因为有两个实例，一个是put一个是get，hashCode不同。
       有关hashCode的覆盖约定这里不再赘述。
NO.10、始终要覆盖toString
       默认的toString方法返回的信息无意义，可以返回有意义的格式化数据。
NO.11、谨慎改写clone方法
       对象要克隆，必须实现Cloneable的Clone()方法：

 

    public Object clone()  
    {  
    try  
    {  
    return super.clone();  
    }  
    catch(CloneNotSupportedException e)  {}  
    }

       当你要clone的类里面含有可修改的引用字段的时候（不保留原有引用关系）

 

    public Object clone() throws CloneNotSupportedException  
    {
           Stack Result  = (Stack)super.clone();  
           Result.elements = (Object[])elements.clone();//elements是stack类中可修改的引用字段
           Return result;  
    }

       注意：使用Object中的默认clone对某个类进行克隆时，任何类型的数组属性成员都只是浅复制，即克隆出来的数组与原来类中的数组指向同一存储空间，其他引用也是这样，只有基本类型才深复制。

       深拷贝：逐一复制并创建新实例

 

//递归地深层复制每个链表节点对象
  Entry deepCopy(){
       return new Entry(key, value, next == null ? null : next.deepCopy());
  }
//如链表较长，容易导致栈溢出，因此可以：
Entry deepCopy(){
       Entry result = new Entry(key, value, next);
       for(Entry p = result; p.next != null; p = p.next){
          p.next = new Entry(p.next.key, p.next.value, p.next.next);
       }
       return result;
}
@Override public HahsTable clone() {
       try{
              HashTable result = (HashTable)super.clone();
              result.buckets = new Entry[buckets.length];
              // 采用循环的方式对每个桶引用的单链表进行深层拷贝
              for(int i = 0; i < buckets.length; i++){
                  if(buckets[i] != null){
                    result.buckets[i] = buckets[i].deepCopy();
              }
           }
              return result;
       } catch (CloneNotSupportedException e) {
              throw new AssertionError();
             }
}

NO.12、考虑实现Comparable接口
       该方法是Comparable接口的唯一方法，允许进行简单的相等比较，也允许执行顺序比较，一个类实现comparable接口就表明其实例具有内置的排序关系。Java中所有的值类都实现了Comparable。将当前对象与指定对象进行顺序比较时，返回负整数、0或正整数（<、=、>），如果指定对象的类型无法比较，则抛出ClassCastException或者NullPointException异常，compareTo方法应遵守：自反性、对称性、传递性和非空性的限制条件。在实现数值比较的compareTo方法时还要防止值域溢出。
NO.13、使类和成员的可访问能力最小化
       通过访问修饰符，可把模块之间的耦合程度降到最低，控制安全性：
       public表示这个类在任何范围都可用。
       protected表示只有子类和包内的类可以使用
       private-package(default) 包级私有，表示在包内可用
       private表示只有类内才可以用
       尽可能使每个类或者成员不被外界访问，即使用尽可能最小的访问级别。除公有静态final域的情形外，公有类不应包含公有域，且确保有静态final域所引用的是不可变的。
NO.14、在公有类中使用访问方法而非公有域
       方法可以做很多事情，大家都懂的——
NO.15、使可变性最小化
       不可变的类不容易出错，更加安全，如String、基本类型的包装类、BigInteger和BigDecimal。这些类实例不能再修改，整个生命周期不变，当然加上final是另一回事。
       不可变类遵循下面五条规则：
       ①不要提供任何会修改对像的方法；
       ②保证没有可被子类改写的方法；
       ③使所有的域都是final的；
       ④使所有的域都成为私有的；
       ⑤保证对于任何可变组件的互斥访问。

       使一个类成为不可变类有三种方法：
       ①类声明为final；
       ②每一个方法都成为final的，好处在于其子类可以继续扩展新的方法；
       ③把类的构造函数声明为私有的或者包级私有的，增加静态工厂方法，来代替公有的构造函数
NO.16、组合优先于继承
       意思就是用组合更灵活，如果有条件用组合尽量不要用继承，因为继承破坏了封装，导致键壮性不足，不变扩展。
NO.17、要么为继承而设计并提供文档说明，要么就禁止继承（final类、所有的构造函数变为私有）
       这个因人而异，结合实际情况为准，设计继承类时适当考虑：
       1、描述改写每个方法带来的影响
       2、被继承的类的构造函数一定不能调用可被改写或覆盖的方法，因为超类的构造函数会在子类的构造函数之前运行，所以子类中改下版本的方法将会在子类的构造函数运行之前就被调用
NO.18、接口优于抽象类
       这个是OO设计的一个原则，了解抽象类和接口的主要区别以及什么时候需要用抽象类和接口即可，大家都懂得，不做赘述。
       抽象类：可包含具体实现和成员声明，作公共抽象时使用，可继承一些特性
       接口：行为约束，方法PUBLIC
NO.19、接口只用于定义类型
       类实现接口时，接口就充当可以引用这个类的实例的类型。为其他目的而定义接口是不恰当的（常量接口违反了上面的条件，不值得效仿）：
       1、导致把实现细节泄露到该类的导出API中。
       2、如果类被修改，不需要使用这些常量，还须实现这个接口，以确保二制兼容性。
       3、如果非final类实现常量接口，所有子类的命名空间也会被接口中的常量污染。
       OK，既然是仅定义类型，那就不可能提供再进行类型变量声明，如定义一个常量是错误的。但可通过类、接口、枚举等作为参数进行导出：

 

public class PhysicalConstants {
  private PhysicalConstants() { }  // 私有构造器
  public static final double AVOGADROS_NUMBER   = 6.02214199e23;
}

NO.20、类层次优于标签类
       意思就是利用继承保持层次关系，多态与派生。
NO.21、用类代替结构
       意思是不要把类单纯的用于结构类型定义，要包含OO的思想。

 

    class Point  
    {  
     private float x;  
     private float y;  
    } 
    class Point  
     {  
      private float x;  
      private float y;  
      public Point(float x,float y)  
      {  
            this.x=x;  
            this.y=y;  
      }  
       public float getX(){retrun x;}  
       public float getY(){return y;}  
       public void setX(float x){this.x=x;}  
       public void setY(float y){this.y=y;}  
     }  

       当然，如果类是包级私有的，或是一个私有的嵌套类，则直接暴露值域也可以。
NO.22、用类来代替enum结构
       定义类来代表枚举类型的单个元素，并且不提供任何公有的构造函数，好处多多。
NO.23、用类和接口来代替函数指针
       用类和接口的应用可以实现C中函数指针一样的功能，下面的这个例子已经用烂了。

 

    public interface Comparator{  
      public int compare(Object o1,Object o2);  
    }

       为了实现指针的模式，声明一个接口来表示该策略，并且为每个具体策略声明一个实现了该接口的类，如果策略只用一次，那么定义匿名类；如果策略类反复使用，那么定义为私有的的静态成员类
NO.24、用函数对象表示策略
       例如一个类仅作比较使用，然后通过接口定义比较策略。

 

public class StringLengthComparator implements Comparator {
       private StringLengthComparator() {}
       public int compare(String s1, String s2) {
              return s1.length() - s2.length();
       }
}
Arrays.sort(strArr,new Comparator(){
       public int compare(String s1, String s2) {
              return s1.length() - s2.length();
}});

NO.25、优先考虑静态成员类
    部分描述不一定正确，大家自行鉴别：
        嵌套类只为它的外围类提供服务。
        嵌套类分为四种：静态成员类、非静态成员类、匿名类和局部类（后面三种称为内部类）
       补充一点：静态类(static class)即定义了静态方法，静态变量，静态代码块或者内部静态类的类。这些静态成员不需要实例化即可直接引用，类的内部也不能使用this。
       静态成员类的一种常见用法是作为公有的辅助类，仅当与它的外部类一起使用时才有意义，如：Calculator.Operation.PLUS。
       非静态成员类一种常见用法是定义一个Adapter，允许外部类的实例被看作是另一个不相关的类的实例。
       如果成员类的每个实例都需要一个指向其外围实例的引用，则把成员类做成非静态的；否则就做成静态的。
       如果嵌套类的实例可以在它外围类的实例之外独立存在，这个嵌套类就必须是静态成员类，意思是A中定义了A1，B也想用A1，则A1定义为静态成员类。
NO.26、不使用原生态类型
       不要在新代码中使用。原生态类型只为了与引入泛型之前的遗留代码进行兼容和互用而提供的。另外Set