《Effective Java》笔记

2. 创建和销毁对象

2.1 考虑用静态方法代替构造器

what

// 静态方法
public static Boolean valueOf(boolean b){
    return b ? Boolean.TRUE : Boolean.FALSE;
}
// demo1 
Boolean a1 = new Boolean(true);
Boolean a2 = new Boolean(true);
Boolean b1 = Boolean.valueOf(true);
Boolean b2 = Boolean.valueOf(true);
if (a1 == a2){
  System.out.println("==========1"); //NO
}
if (b1 == b2){
  System.out.println("==========2"); //OK
}
// demo2
 Map> m = new HashMap>();
 Map> m = HashMap.newInstance();
 public static  HashMap newInstance(){
   return new HashMap();
 }

why

静态方法相比构造器优点:

• 有名称
• 不必每次调用时创建一个新的对象（此时可以用==代替equals，从而提升性能，demo1）
• 可以返回原返回类型的任何子类型对象，从而隐藏实现类使api更简洁（服务提供者框架）
• 创建参数化类型实例时，利用类型推导(type inference)代码更简洁

缺点：

• 类如果没有公有的或受保护的构造器，就无法被子类化

2.2 使用构建器代替多个参数的构造器

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories = 0;

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

        public Builder calories(int val) {
            calories = val;
            return this;
        }


        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
    }

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

2.3 使用私有构造器或枚举强化Singleton属性

what

Singleton指仅被实例化一次的类，常依赖代表那些本质上唯一的组件。

好的单例模式要做到：

• 防止反射，序列化，高并发导致的单例失败；
• 能便捷的切换成多例模式

HOW

自己动手实现牛逼的单例模式

2.4 通过私有构造器强化不可实例化的能力

防止缺省的构造器导致类仍可以实例化，可以主动实现个无参构造器，并在其中返回异常，这样做的缺点是导致该类无法子类化

2.5 避免创建不必要的对象

• 重用不可变对象String s = "a"代替String s = new String("a")
• 重用已知不会被修改的可变对象，如date

class Person {
    private final Date birthDate;

    public Person(Date birthDate) {
        // Defensive copy - see Item 39
        this.birthDate = new Date(birthDate.getTime());
    }

    // Other fields, methods

    /**
     * The starting and ending dates of the baby boom.
     */
    private static final Date BOOM_START;
    private static final Date BOOM_END;

    static {
        Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
        BOOM_START = gmtCal.getTime();
        gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
        BOOM_END = gmtCal.getTime();
    }

    public boolean isBabyBoomer() {
        return birthDate.compareTo(BOOM_START) >= 0
                && birthDate.compareTo(BOOM_END) < 0;
    }
}

• 优先使用基本类型，而不是装箱类型
• 除非是重量级的大对象，如数据库连接池，不然没必要去刻意维护个对象池来实现重用，因为小对象的创建回收是廉价的，相比维护对象池而言（代码乱，占用内存）

2.6 清除过期的对象引用

为什么清除：内存泄露，占用内存，导致机器性能越来越慢，甚至内存溢出

清空对象引用应该是一种例外，而不是规范行为，应当最小化变量的作用域。

哪些情况会导致过期引用

• 自己管理内存的类

• 缓存：一旦把对象引用放到缓存里，就容易被遗忘。

  只要缓存之外存在对某个键的引用，该键才有意义，考虑使用WeakHashMap实现该缓存

• 监听器和其他回调：如注册回调却没有显式取消回调。确保回调可以垃圾被垃圾回收的最佳方法是只保存弱引用(weak reference)，例如保存成WeakHashMap的键

2.7 避免使用finalizer()

3. 对所有对象都通用的方法

4. 类和接口

4.1 使类和成员的可访问性最小化

信息隐藏：模块之间只通过他们的api通信，一个模块不需要知道其他模块的实现细节

实例域不能是公有的，否则即放弃了对存储在这个域中的值进行限制的能力，也因此包含公有可变域的类不是线程安全的

长度非零的数组总是可变的，不要返回它或者将其声明为公有的静态final数组域。处理办法是声明成私有的，然后返回不可变数组，或者数据的拷贝(clone())

4.2 在公有类中使用访问方法而不是公有域

如果公有类暴露了数据域，那今后想改也晚了，应该调用它的代码已经遍布客户端

4.3 使可变性最小化

what

不可变类是其实例不能被修改的类，实例中所有信息都在创建时提供，如String,基本类型的包装类,BigInteger,BigDecimal.

不可变对象只有一个状态，即被创建时的状态

不可变对象是线程安全的，不需要同步，故可被自由的共享，进而永远不需要保护性拷贝

不可变对象的缺点是每个不同的值都需要一个单独的对象

How

为使类成为不可变，遵循5条原则：

不可变类的5条原则.jpg

4.4 复合优于继承

继承的缺点：

• 打破了封装性，在子类的实现依赖父类的某个特性时会是个问题，其功能可能随父类发行版本的变化而失效，如HashSet中addAll()是调用add()实现的，所以统计add()元素个数时，只能重写add()方法
• 把超类api中的缺陷传递到子类

导致问题的另一个原因，在超类在后续的发行方法中会新增加方法：

• 子类有方法与新加的方法签名相同但返回类型不同，则编译报错
• 子类有方法与新加的方法签名且返回类型相同，其实现可能不会遵循该新方法的约定

包装类(复合，把现有的类变成新类的组件;新类方法中调用超类中对应方法并返回其结果，称为转发方法)的缺点：

• 不适用在回调框架（callback framework），可能会导致SELF问题，因为被包装起来的对象并不知道它外面的包装对象

只有A IS B 时，才使用继承

4.5 接口优于抽象类

区别：

• 抽象类允许包含某些方法的实现而接口不允许；
• 为实现抽象类定义的类型，必须成为抽象类的子类

抽象类的弊端：

• 破坏类层次，某个类一旦实习抽象类，其所有后代都要扩展这个新的抽象类，无论这个后代是否合适
• 不能Mixin，接口可以实现多个，但类只能继承一个
• 无法构建非层次结构的类型框架

抽象类优点：

• 可以增加已实现的方法

骨架实现(skeletal implementtation)：使用抽象类实现接口,亦被称作abstractInterface，可以使程序员很容易提供自己的接口实现,对于重要的接口，最好提供对应的骨架实现类。

通过对你导出的每个重要接口都提供一个抽象的骨架实现类（skeletal implementation）类，把接口和抽象类的优点结合起来。接口的作用仍然是定义类型，但是骨架实现类接管了所有与接口实现相关的工作（可以只实现需要的方法）。

// 应用骨架类实现自己的List
public class IntArrays {
    static List intArrayAsList(final int[] a) {
        if (a == null)
            throw new NullPointerException();

        return new AbstractList() {
            public Integer get(int i) {
                return a[i]; // Autoboxing (Item 5)
            }

            @Override
            public Integer set(int i, Integer val) {
                int oldVal = a[i];
                a[i] = val; // Auto-unboxing
                return oldVal; // Autoboxing
            }

            public int size() {
                return a.length;
            }
        };
    }

    public static void main(String[] args) {
        int[] a = new int[10];
        for (int i = 0; i < a.length; i++)
            a[i] = i;
        List list = intArrayAsList(a);

        Collections.shuffle(list);
        System.out.println(list);
    }
}

4.6 优先考虑静态成员类

嵌套类：

• 定义在另一个类内部的类，目的在于为其外围类服务，如果其可能用在其他类，应该是顶层类。
• 分类：静态成员类、内部类（非静态成员类，匿名类，局部类）

[图片上传失败...(image-c90921-1553657651829)]

5. 泛型

5.1 不要在新代码中使用原生态类型

每个泛型都会定义一个原生态类型（Raw Type），即不带任何实际类型参数的泛型名称。例如，与List对应的原生态类型时List。原生态类型就像从类型声明中删除了所有泛型信息一样。实际上，原生态类型List与java平台没有泛型之前的接口类型List完全一样。

List