《Effective Java》第1章 创建和销毁对象
第1条 用静态工厂方法代替构造器
这个静态工厂，与设计模式中的静态工厂不同，这里的静态工厂方法，替换为“静态方法”比较好理解，主要就是建议编写静态方法来创建对象。
使用静态方法的好处：
1、静态方法有名称，可以确切地描述功能，比如根据哪些参数，返回哪种类型；
2、不需要先创建对象实例，再调用方法来创建所需的对象；使用静态方法可以直接使用类名加静态方法名即可调用；
3、可以返回原类型的任何子类型对象；
4、可以通过传入不同的参数，获得不同的返回值；
5、方法返回的对象所属的类，在编写包含该静态方法的类时可以不存在，比如JDBC API；
6、使用构造方法创建对象时的开销，相对于使用静态方法来说，要大得多，比如Boolean.valueOf(Stirng)与new Boolean(String)；
缺点和不足
1、静态方法中要想返回对象，那么该对象所属的类必须有可以访问的构造器，否则不能被实例化；
2、静态方法比较难被发现；
第2条 遇到多个构造器时考虑使用构建器
当类的构造器或者静态工厂中具有较多的参数时，或者参数可能后期会增加时，那么在设计类的时候，可以使用Builder模式。
package cn.ganlixin.effective_java;
public class BuilderTest {
public static void main(String[] args) {
final Person person = new Person.Builder().id(1).name("ganlixin").build();
}
}
class Person {
private int id;
private String name;
private Person(Builder builder) {
id = builder.id;
name = builder.name;
}
public static class Builder {
// Builder一般来说包含有外层类相同的属性
private int id;
private String name;
public Builder id(int val) { this.id = val; return this; }
public Builder name(String val) { this.name = val; return this; }
public Person build() { return new Person(this); }
}
}
上面的代码，使用Lombok的话，只需要使用一个@Builder注解即可：
package cn.ganlixin.effective_java;
import lombok.Builder;
public class LombokBuilder {
public static void main(String[] args) {
final Person person = new Person.PersonBuilder().id(1).name("ganlixin").build();
}
}
@Builder
class Person {
private int id;
private String name;
}
第3条：用私有构造器或者枚举类型强化Singleton属性
单例模式：
1、通过私有化构造器，可以防止客户端使用new关键字创建对象；
2、提供静态方法获取单例对象；
以上两点存在的问题，可以使用AccessibleObject.setAccessible()方法通过反射机制调用构造器，可以在构造其中判断是否已经创建实例，如果已创建，则抛出异常；
3、单例对象的序列化问题；
使用枚举类型创建单例属性，例子如下：
public class SingletonEnum {
public static void main(String[] args) {
final OneDemo instance = OneDemo.INSTANCE;
instance.test();
}
}
enum OneDemo {
INSTANCE;
// 定义其他function
public void test() {
// .........
}
}
第4条：通过私有构造器强化不可实例化的能力
当我们创建工具类的时候，一般来说工具类不应该被实例化，虽然可以将工具类声明为抽象类来避免被实例化，但是这样并不好，因为抽象类的子类可以实例化！
解决方案：显示声明工具类的无参构造方法，在其中抛出异常即可。
定义类的时候使用final（类级别），指定不允许子类继承。
class MyUtil {
private MyUtil(){ throw new RuntimeException("工具类不应该被实例化"); }
// 声明工具类中的方法
public static void myMethod(){}
}
第5条：优先考虑依赖注入来引用资源
主要就是讲依赖注入。
问题是这样的：有一个邮件白名单，对于接收到的邮件，需要先进行过滤一遍（匹配白名单），那么可能会写出下面的代码：
// 邮件过滤器
class MailChecker{
// 白名单列表，在代码中写死
private List<String> whiteList = new ArrayList<String>(){{
add("123"); add("456"); add("789");
}};
// 进行检验操作
public boolean isValid(String email) {
return whiteList.contains(email);
}
}
上面的代码其实并不好，原因：
1、过滤名单写死了；
2、只能进行邮件过滤；这一点可能会有疑惑，功能专一不好吗？这没问题，但是如果有一个“电话过滤器”是不是又要有一个PhoneChecker呢？
推荐做法：在过滤器中不写死whiteList，白名单由外部传入，过滤器的功能就是进行过滤而已，改为如下：
public class UseInject {
public static void main(String[] args) {
// 假设phoneList是外界传入的，或者是文件中读入的
List<String> phoneList = null;
Checker phoneChecker = new Checker(phoneList);
phoneChecker.isValid("123");
}
}
class Checker{
private List<String> whiteList;
// 接收外界传入的白名单（可以是电话、邮箱、地址....）
public Checker(List<String> whiteList) {
this.whiteList = whiteList;
}
// 检验操作
public boolean isValid(String val) {
return whiteList.contains(val);
}
}
如果是使用Spring这些框架，可以直接利用依赖注入，比如：
public class UseInject {
@Value("${phoneList}")
private static List<String> phoneList;
public static void main(String[] args) {
Checker phoneChecker = new Checker(phoneList);
phoneChecker.isValid("123");
}
}
第6条：避免创建不必要的对象
1、虽然Java有自动装箱和自动装箱，但是请尽量使用基本数据类型；
2、对于提供了静态工厂方法和构造器的类来说，应该优先使用静态方法而非构造器创建对象；
3、有一些对象不应该被重复创建，比如正则表达式的Pattern实例；
4、应该避免维护自己的对象池，数据库连接池除外，因为建立数据库连接的代价比较大，创建普通对象的代价则相对来说很小；
5、不要太死板，有些时候，为了避免创建不必要的对象，会付出更多的代价；
第7条：消除过期的对象引用
1、如果类是自己管理内存，那么就需要需要警惕内存泄漏问题，一旦元素被释放掉，则该元素包含的任何对象应用都应该被清空；
2、缓存导致内存泄漏，可以使用WeakHashMap；
3、如果提供服务给客户端调用，要警惕客户端的反复调用是否会反复产生对象，但是却没有清理垃圾；
第8条：避免使用终结方法和清除方法
1、终结方法（finalizer）和清除方法（cleaner）不能保证会被及时的执行，从一个对象变为不可达开始，到执行这两个方法的事件是任意长的，所以，注重时间的任务不应该由finalizer和cleaner来完成；
2、永远不应该依赖finalizer和cleaner方法来更新重要的持久状态，因为这两个方法可能没有机会被执行；
3、System.gc和System.runFuinalization只能增加finalizer和cleaner的执行机会，注意，增加可能性，但不是保证，100%；
4、finalizer中出现异常，终结过程会终止，可怕吧，想死还死不掉；
5、降低程序性能、finalizer attack；
第9条：try-with-resource优先于try-finally
要使用try-with-resource，需要类实现AutoCloseable接口（大多数类都实现了）。
下面以书中的例子举例：
public static void notSuggest() throws IOException {
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new FileReader("demo.txt"));
bufferedReader.readLine();
} finally {
bufferedReader.close();
}
// 注意，上面的demo.txt不存在时，报异常FileNotFoundException，然后finally中的close也会报错，但是close的异常会覆盖readLine的异常
// 所以调用notSuggest()方法，只会看到close的异常Exception in thread "main" java.lang.NullPointerException
}
改成下面这样就可以捕获所有异常了，但是看起来，代码好臃肿：
public static void notSuggest2() {
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new FileReader("demo.txt"));
bufferedReader.readLine();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// 虽然可以打印出所有的异常信息（FileNotFoundException和close的NullPointerException异常）
// 按照常识，如果前面一步已经错了，就不应该再走下去，但是FileNotFoundException之后，还是会执行finally中的close，结果又出现异常
}
推荐使用try-with-resource
public static void suggest() {
try (BufferedReader bufferedReader = new BufferedReader(new FileReader("demo.txt"))) {
bufferedReader.readLine();
} catch (Exception e) {
e.printStackTrace();
}
// 不需要catch每一个子异常，比如FileNotFoundException，直接写一个IOException或者Exception即可
// 上面demo.txt不存在，所以会出现java.io.FileNotFoundException，但是没有报第二个异常哦
}
