Effective Java 读书笔记（二）

ForCleanCode 为笔者读书总结，出于自身理解目的总结！

JoshBloch.jpg

一丶用私有构造期或者枚举强化Singleton属性。

1丶单列：仅仅被实例化一次的类。

在JAVA 1.5之前 实现单列 有两种常见方式:

1.第一种方式:公有域。

/**
 * Created by zhaoyuanchao on 2018/5/11.
 * 1丶私有化构造器
 * 2丶唯一得静态成员INSTANCE 确保访问了唯一实例
 */

public class Elvis {
    
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() {
    }
}

问题：
享有特权得客户端可以借助 AccessibleObject.setAccessible方法，通过反射机制，调用私有构造器。 （可以同过 让他被要求创造第二个实例的时候抛出异常 来抵御这种攻击）

2.第二种方式：（看来J神对静态工厂方法情有独钟）

/**
 * Created by zhaoyuanchao on 2018/5/11.
 * 1丶共有的静态工厂方法，调用唯一实例
 */

public class Elvis {

    private static final Elvis INSTANCE = new Elvis();
    private Elvis() {
    }
    public static Elvis getInstance(){
        return INSTANCE;
    }
}

两种方式的比较：

1丶公有域方式：
组成类的成员变量很清楚的声明了类是一个Singleton.
共有静态域是final的，所以总是包含单个相同的引用。

2丶静态工厂方式:
灵活性：在不改变其API的前提下，我们可以改变该类是否应该是一个SIngleton的想法。

这两种方式在序列化后，为了保证Singleton，必须声明所有的实例都是transient,并提供一个readResolve方法：

public class Elvis implements Serializable {

    private static final Elvis INSTANCE = new Elvis();
    private Elvis() {
    }
    public static Elvis getInstance(){
        return INSTANCE;
    }

    /**
     * 保证反序列化后唯一实例
     * @return
     */
    private Object readResolve(){
        return INSTANCE;
    }
}

3丶第三种方式实现单列：

public enum  Elvise {
    INSTANCE
}

优点：
(1) 简洁.
(2) 无偿提供了序列化机制
(3) 单元素的枚举 已经成为实现单列的最佳方式！

二丶避免创建不必要的对象
1丶一般对象的创建

/**
     * 每次执行的时候都会创造新的实例，会创建很多不必要的实例，
     * 因为每调用一次构造器 就会创造一个新的实例。
     */
    String mString = new String("string"); //不要这样创建
    /**
     * 至创建一个String的实例
     */
    String mStrings = "string";

2丶静态工厂方法优先于构造器方法。

/**
     * 每次都会创建出新对象
     */
    Boolean s = new Boolean("ss");
    /**
     * 重用传入对象
     */
    Boolean getS = Boolean.valueOf("ss");


/**
     * Returns a {@code Boolean} with a value represented by the
     * specified string.  The {@code Boolean} returned represents a
     * true value if the string argument is not {@code null}
     * and is equal, ignoring case, to the string {@code "true"}.
     *
     * @param   s   a string.
     * @return  the {@code Boolean} value represented by the string.
     */
    public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }

3.重用那些 已知不被修改的量。

（1）未被重用的列子：

public class Person {
    private final Date bitrhDate;

    public Person(Date bitrhDate) {
        this.bitrhDate = bitrhDate;
    }

    /**
     * 每次查询的时候 都会创建 一个Calender 一个TimeZone 两个Date,
     * 这些都是固定值，没有必要每次查询都创建对应实例
     * @return
     */
    public boolean isBabyBoomer(){
        Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        calendar.set(1946,Calendar.JANUARY,1,0,0,0);
        Date dateStart = calendar.getTime();
        calendar.set(1965,Calendar.JANUARY,1,0,0,0);
        Date dateEnd = calendar.getTime();
        return bitrhDate.compareTo(dateStart) >= 0 &&
                bitrhDate.compareTo(dateEnd) < 0;
    }
}

(2) 静态初始化器 复用常量(改进版本)

public class Person {
    private final Date bitrhDate;
    private static final Date DATE_START;
    private static final Date DATE_END;

    public Person(Date bitrhDate) {
        this.bitrhDate = bitrhDate;
    }

    /**
     * 只在第一次运行的时候，创建实例一次
     */
    static {
        Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        calendar.set(1946,Calendar.JANUARY,1,0,0,0);
        DATE_START = calendar.getTime();
        calendar.set(1965,Calendar.JANUARY,1,0,0,0);
        DATE_END = calendar.getTime();
    }
    
    public boolean isBabyBoomer(){
        return bitrhDate.compareTo(DATE_START) >= 0 &&
                bitrhDate.compareTo(DATE_END) < 0;
    }
}

比较：
两种代码 在J神的电脑上 调用一千万次：
第一种：32000ms 第二种：130ms
快了将近 250倍。

4丶自动装箱和 拆箱造成的问题：
（1）自动装箱 和 拆箱 实际上就是 ，基本类型和 装箱基本类型 可以自动转换得一种功能；

Long sum = 0L;
for(long i = 0;i < Integer.MAX_VALUE; i++){
  sum += i;
}

这段程序因为打错了一个字符，导致效率会降低。
变量sum被声明成Long而不是long，意味着程序构造了很多多余得Long实例。将Long 改成long ，在我的机器上运行 时间从43S减少到了6.8S。

结论：
优先使用基本类型,而不是装箱基本类型,当心无意识得 自动装箱。

三丶消除过期得对象引用：

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INIYITAL_CAPACITY = 16;

    public Stack(Object[] elements) {
        this.elements = new Object[DEFAULT_INIYITAL_CAPACITY];
    }
    public void push(Object object){
        ensureCapacity();
        elements[size++] = object;
    }
    
    public Object pop(){
        if (size == 0)
            throw new EmptyStackException();
            return elements[--size];
    }

    private void ensureCapacity() {
        if (elements.length == size){
            elements = Arrays.copyOf(elements,2*size+1);
        }
    }
}

观察：
这段程序 会随着内存得增加 效率会不断的降低！

原因是 总栈中被pop出去的对象，将不会被当作垃圾回收，即使使用栈的程序不在引用这些对象。他们也不会被回收了！
栈内维护着这些对象的过期引用(永远也不会被解除的引用)。

修复方法：

    public Object pop(){
        if (size == 0)
            throw new EmptyStackException();
            Object result = elements[--size];
            elements[size] = null;
            return result;
    }

清空过期引用。
清空对象引用应该是一种列外，而不是一种规范行为！

2：内存泄漏的第二个常见来源：缓存！
3：内存泄漏的第三个常见来源：回调！

可以只保存他们的弱引用方式来规避此类问题（weak reference）

四: 避免使用终结方法：
1.finalizer:通常是不可预测，也很危险的！

缺点：
1：不能保证会被及时的执行：
注重时间的任务 不能用终结方法。
2：Java语言的规范不仅不保证 终结方法会被及时执行，而且根本就保证不了它们会被执行。
3：会造成严重的性能损失