Effective java 中文版（第2版）

线程安全性的几种级别：1.不可变的(immutable)--这个类的实例是不变的，所以不需要外部的同步。例如：String、Long和BigInteger2.无条件的线程安全(unconditionally thread-safe)--这个类的实例是可变的，但是这个类有着足够的内部同步，所以它的实例可以被并发使用，无需任何外部同步。例如：Random和ConcurrentHashMap3.有条件的线程安全(conditionally thread-safe)--除了有些方法为进行安全的并发而使用需要外部同步之外，这种线程安全级别与无条件的线程安全相同。例如：Collections.synchronized包装返回的集合，它们的迭代器(iterator)要求外部同步4.非线程安全(not thread-safe)--这个实例是可变的。为了并发地使用它们，客户必须利用自己选择的外部同步包围每个方法调用（或者调用序列）例如:ArrayList和HashMap5.线程对立的(thread-hostie)--这个类不能安全地被多个线程并发使用，即使所有的方法调用都被外部同步包围。

本想给这本书4星的，因为感觉没有Scott Meyers的《Effective C++》、《More Effective C++》、《Effective STL》系列写得好；考虑到Java学习上只此一本《Effective Java》还是给5星吧。毕竟这本书也还是很值得一读的！抄录一些笔记，空白的条目表示没看明白，以后有新的理解再补充。第一章 引言一， 代码应该被重用，而不是被拷贝。第二章 创建和销毁对象一，考虑用静态工厂方法代替构造器public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE;} 静态工厂方法能够为重复的调用返回相同的对象。静态工厂惯用名称：valueOf, of, getInstance, newInstance, getType, newType.二, 遇到多个构造器参数时要考虑用builder三，用私有构造器或者枚举类型强化Singleton属性1，public class Elvis { public static final Elvis INSTANCE = new Elvis(); private Elvis() { .... } public void leaveTheBuilding() {...}}2, public class Elvis { private static final Elvis INSTANCE = new Elvis(); private Elvis() { ... } public static Elvis getInstance() { return INSTANCE; } public void leaveTheBuilding() { ... }}3, 单元素的枚举类型已经成为实现Singleton最佳方法public enum Elvis { INSTANCE; public void leaveTheBuilding() { ... }}四，通过私有构造器强化不可实例化的能力只包含静态方法和静态域的工具类(utility class)实例对它没任何意义，只要让这个类构造器私有就可以保证不会被实例化。public class UtilityClass { private UtilityClass() { throw new AssertionError(); }副作用：这个类不能被继承。所有的构造器都必须显示或隐式地调用超类的构造器。五，避免创建不必要的对象构造器在每次被调用时都会创建一个新的对象。可以使用静态工厂方法代替构造器，以避免创建不必要的对象。例：Boolean.valueOf(String)。静态初始化，只需初始化一次。延迟初始化。六，消除过期的对象引用只要是类是自己管理内存，程序员就应该警惕内存泄漏。七，比用使用终结方法终结方法(finalizer)通常是不可以预测的，也是很危险的。终结方法的缺点在于不能保证会被及时地执行。在C++中，析构器是回收一个对象所占资源的常规方法。Java中，一般用try-finally完成类似的工作。第三章 对于所有对象都通用的方法八，覆盖equals时请遵守通用约定==比较的是引用，equals比较的是值！九，覆盖equals时总要覆盖hashcode@Override public boolean equals(Object O) { ... }@Override public int hashCode() { ... }相等的(equals)的对象必须具有相等的hash code。不相等的两个对象，hash code有可能相等。Eclispe提供了代码生成工具(Source->Generates hashCode() and equals()...)十，始终要覆盖toString@Override public String toString() { ... }十一，谨慎地覆盖clone()方法public interface Cloneable { } 如果一个类实现了Cloneable，Object的clone方法就会返回该对象的逐域拷贝，否则就会抛出CloneNotSupportedException.clone()就是另一个构造器；你必须确保它不会伤害到原始的对象，并确保正确地创建被克隆对象中的约束条件。(深度拷贝,deep copy）无需调用构造器就可以创建对象。协变返回类型(covariant return type),override方法的返回类型可以是被覆盖方法返回类型的子类型。所有实现Cloneable接口的类都应该用一个公有方法覆盖clone。此方法首先调用super.clone(),然后clone自身域。@Override public Stack clone() { try { Stack result = (Stack)super.clone(); result.elements = elements.clone(); return result; } catch (CloneNotSupportedException e) { throw new AssertionError(); }}另一个实现对象拷贝的办法是提供一个拷贝构造器或拷贝工厂：public Yum(Yum yum) copy ctorpublic static Yum newInstance(Yum yum); copy factory十二，考虑实现Comparable接口类实现了Comparable接口，就表明它的实例具有内在的排序关系。public interface Comparable<T> { int compareTo(T t);} 当该对象小于、等于或大于指定对象的时候，分别返回一个负整数、零或正整数。第四章 类和接口十三， 使类和成员的可访问性最小化private, package-private, protected, public十四，在公有类中使用访问方法而非公有域十五，使可变性最小化十六，组合优先于继承实现继承(implementation inheritance), 接口继承(interface inheritance)组合(composition), 转发方法(forwarding method)包装类(wrapper class)-->Decorator模式十七，要么为继承而设计并提供文档说明，要么就禁止继承十八，接口优于抽象类抽象类允许包含某些方法的实现；接口不允许。为实现抽象类定义的类型，类必须成为抽象类的一个子类，Java只允许单继承；可以implement多个接口十九，接口只用于定义类型静态导入(static import)：JUnit，ass ertEquals()二十，类层次优于标签类二十一，用函数对象表示策略class StringLengthComparator { public int compare(String s1, String s2) { return s1.length() - s2.length(); }} StringLengthComparator没有域是无状态的，因此非常适合成为Singleton。class StringLengthComparator { private StringLengthComparator() { } public static final StringLengthComparator INSTANCE = new StringLengthComparator(); public int compare(String s1, String s2) { return s1.length() - s2.length(); }}public interface Comparator<T> { public int compare(T t1, T t2);} Arrays.sort(stringArray, new Comparator<String>() { public int compare(String s1, String s2) { return s1.length() - s2.length(); }}; 可以将函数对象存储到一个私有的静态final域中，并重用。class Host { private static class StringLengthComparator implements Comparator<String>, Serializable { public int compare(String s1, String s2) { return s1.length() - s2.length(); } } public static final Comparator<String> STRING_LENGTH_COMPARATOR = new StringLengthComparator(); //.....} 函数指针的主要用途就是实现策略(Strategy)模式。Java中声明一个接口表示策略，并且为每个具体策略声明一个实现了该接口的类。例:Arrays.sort(array, comparator);二十二，优先考虑静态成员类嵌套类有四种：静态成员类，非静态成员类，匿名类，局部类。非静态成员类的每个实例都隐含着与一个外围实例相关联匿名类一种常见用法是动态地创建函数对象；另一种用法是创建过程对象，比如Runnable,Thread或者TimerTask实例；第三种常见的用法是在静态工厂方法的内部。第五章 泛型二十三，不要在新代码中使用原生态类型二十四，消除非受检警告@SuppressWarnings("unchecked")二十五，List优先于数组二十六，优先考虑泛型二十七，优先考虑泛型方法二十八，利用有限制通配符来提升API的灵活性二十九，优先考虑类型安全的异构容器第六章 枚举和注解三十，用enum代替int常量三十一，用实例域代替序数public enum Ensemble { SOLO(1), DUET(2), TRIO(3), QUARTET(4); private final int numberOfMusicians; Ensemble(int size) { this.numberOfMusicians = size; } public int numberOfMusicians() { return numberOfMusicians; }} 三十二，用EnumSet代替位域三十三，用EnumMap代替序数索引三十四，用接口模拟可伸缩的枚举三十五，注解优先于命名模式三十六，坚持用Override注解三十七，用标记接口定义类型标记接口(marker interface)是没有包含方法声明的接口。例：Serializable第七章 方法三十八，检查参数有效性在方法体得开头处检查参数。三十九，必要时进行保护性拷贝四十，谨慎设计方法签名谨慎选择方法名；避免过长参数列表；参数类型优先使用接口而非具体类；对于boolean参数，优先使用两个元素的枚举类型：public enum TemperatureScale { FAHRENHEIT, CELSIUS }四十一，慎用重载overload方法的选择是静态的，overridden方法的选择是动态。四十二，慎用可变参数四十三，返回零长度的数组或者集合而不是nullCollections.emptySet, emptyList, emptyMapprivate final List<Cheese> cheesesInStock = ...;public List<Cheese> getCheeseList() { if (cheeseInStock.isEmpty()) return Collections.emptyList(); else return new ArrayList<Cheese>(cheeseInStock); }} 四十四，为所有导出的API元素编写文档注释第八章 通用程序设计四十五，将局部变量的作用域最小化四十六，for-each循环优先于传统的for循环for (Iterator i = c.iterator(); i.hasNext(); ) { doSomething((Element)i.next()); // i.remove();}public interface Iterable<E> { Iterator<E> iterator();}三种情况下无法使用for-each循环:过滤，转换，平行迭代。 四十七，了解和使用类库java.lang.*, java.util.*, Collections Framework四十八，如果需要精确的答案，请避免使用float和doubleBigDecimal四十九，基本类型优先于装箱类型永远不要用==做相等测试！Object.equals(object);五十，如果其他类型更适合，则避免使用字符串五十一，需要连接字符串时，用StringBuilder代替String五十二，优先使用接口而非类来引用对象五十三，接口优先于反射机制五十四，谨慎地使用本地方法五十五，谨慎地进行优化必须在设计时考虑性能问题；使用性能剖析工具探测性能瓶颈五十六，遵守普遍接受的命名惯例第九章 异常五十七，只针对异常的情况才使用异常五十八，对可恢复的情况使用受检情况，对编程错误使用运行时异常五十九，避免不必要地使用受检的异常六十，优先使用标准的异常六十一，抛出与抽象相对应的异常六十二，每个方法抛出的异常都要有文档六十三，在细节消息中包含能捕获失败的信息六十四，努力使失败保持原子性六十五，不要忽略异常第十章 并发六十六，同步访问共享的可变数据六十七，避免过度同步六十八，executor和task优先于线程六十九，并发工具优先于wait和notify七十，线程安全性的文档化七十一，延迟延迟初始化七十二，不要依赖于线程调度器七十三，避免使用线程组第十一章 序列化七十四，谨慎地实现Serializable接口七十五，考虑使用自定义的序列化形式七十六，保护性地编写readObject方法七十七，对于实例控制，枚举类型优先于readResolve七十八，考虑用序列化代理代替序列化实例

这里记录一下一个类如何实现序列化和序列化功能。1. 定义一个类。

class User implements Serializable {
}

2. 对User类进行序列化和反序列化。

class Test {
    public static void main(String[] args) throws Exception {
        // 对象序列化
        FileOutputStream fos = new FileOutputStream(new File("/tmp/user.obj"));
        ObjectOutputStream oos = new ObjectOutputStream();
        oos.writeObject(new User());
        fos.close();
        oos.close();

        // 对象反序列化
        FileInputStream fis = new FileInputStream(new File("/tmp/user.obj"));
        ObjectInputStream ois = new ObjectInputStream(fis);
        User nUser = (User)ois.readObject();
        fis.close();
        ois.close();
    }
}

记录一下使用泛型的方法。1. 泛型类。

public class LruCache<K, V> {

}

2. 泛型接口

public interface Cache<K, V> {
}

3. 泛型方法

public <K,V>  V get(K key) {

}