effective java读书笔记之 第一章 创建和销毁对象

第一条: 考虑用静态工厂方法代替构造器
1.与构造器不同的第一大优势在于他们有名字,方便使用者调用,特别是对于参数各个不同的构造器相比,更为清楚.
2.不必在每次调用时都创建一个新的对象,可以为重复调用返回相同的对象,同时减少对象的重复创建,节省系统的开销.
3.他们可以返回原返回类型任何的子类对象,显得更灵活.
示例代码如下:

package main.java.factory;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Paul
 * @version 0.1
 * @date 2018/4/21
 */
public class Services {
    //构造方法私有
    private Services() {
    }

    private static final Map<String, Factory> providers = new ConcurrentHashMap<>();
    public static final String DEFAULT_PROVIDER_NAME = "<def>";

    public static void registerDefaultProvider(String name, Factory p) {
        registerProvider(DEFAULT_PROVIDER_NAME, p);
    }

    private static void registerProvider(String defaultProviderName, Factory factory) {
        providers.put(defaultProviderName, factory);
    }

    //用默认工厂创建服务
    public static service newInstance() {
        return newInstance(DEFAULT_PROVIDER_NAME);
    }

    //用指定工厂创建服务
    public static service newInstance(String name) {
        Factory factory = providers.get(name);
        if (factory == null) {
            throw new IllegalArgumentException("No factory registered with name" + name);
        }
        return factory.newService();
    }

}

interface Factory {
    service newService();
}

interface service {
    //服务方法接口
}

它的缺点在于如果类中不含有public或者protect构造器,就无法子类化,此外静态工厂方法与类中其他静态方法实际上也没有区别,因此可能会难以区分.

第二条: 当成员变量过多时考虑用builder代替构造器
提供了javaBean模式之外的另一种构建方法,保证了线程安全同时具有良好可读性.

package main.java.factory;

/**
 * @author Paul
 * @version 0.1
 * @date 2018/4/22
 */
public class Student {
    private final String name;
    private final int age;
    private final int code;
    private final String clazz;

    public static class Builder {
        private final String name;
        private final int age;
        private int code = 0;
        private String clazz = null;

        public Builder(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public Builder code(int code) {
            this.code = code;
            return this;
        }

        public Builder clazz(String clazz) {
            this.clazz = clazz;
            return this;
        }

        public Student bulid() {
            return new Student(this);
        }
    }

    public Student(Builder builder) {
        name = builder.name;
        age = builder.age;
        code = builder.code;
        clazz = builder.clazz;
    }

    public static void main(String[] args) {
        //客户端调用
        Student student=new Builder("paul", 12).code(2).clazz("一班").bulid();
    }
}

第三条: 使用私有构造器或枚举强化singleton,以及保证其不可实例化
将构造方法私有化,同时在类内部通过publis static final 构造一个对象供外部调用,保证全局唯一性.

第四条: 避免创造不必要的对象
对于同时提供了构造器和静态工厂方法的final类优先使用静态工厂方法.以便重用final对象

第五条: 避免使用终结方法,消除过期的对象引用