写博客我也不知道是不是一个好习惯，但是目前还不知道有什么其他更有效率的学习方法。现在的学习方法：看书，写博客。如果看明白一个东西，去写博客的话，这通常是一个浪费时间的行为，但是这个过程同样帮助自己二次记忆。并不知道写博客到底好不好。就先按照这个来吧。开始新的一本书，《Effective Java》
第一条：考虑用静态工厂方法代替构造器
优点
这一点需要举个例子(书中例子小改动)
class First1<K> { public First1() {} public static <K> First1<K> getNewInstance() { return new First1<K>(); } }
如果用构造器
First1<String> first11 = new First1<String>();
First1<Map<String, List<String>>> first12 = new First1<Map<String, List<String>>>();
静态工厂：
First1<String> first13 = First1.getNewInstance();
缺点：
举个例子
class First2 { private First2() {} } class First3 extends First2{ public First3(){} }
上面代码在First3中会报错。父类无共有构造器，子类根本实例化不了。这时要想到设计原则中的多使用组合少使用继承。这个地方最好就不用继承了，让Frist3成为First2的一个成员变量。
第二条：遇到多个构造器参数时使用构造器
意思简单世界说，当构建一个对象的时候需要很多参数来创建一个对象。这时，可以重叠构造器，就是这个构造器调用下一个构造器，一个一个调用。如果参数少，这个办法比较好，如果有十个参数，想象一下。这时，可以用到JavaBean，无参构造器一个，然后不断的set各个参数，如果用这种方法，也就意味着，这个类在创建之后可以随意改动。这时，可以用下面的办法：
interface SupBuilder<T> {
public T build();
}
public class Second { private int firP; private int secP; private int thiP; private int fouP; private int fivP; private Second(Builder buider) { this.firP = buider.firP; this.secP = buider.secP; this.thiP = buider.thiP; this.fouP = buider.fouP; this.fivP = buider.fivP; } public static class Builder implements SupBuilder<Second>{ private int firP; private int secP; private int thiP; private int fouP; private int fivP; public Builder(int firP, int secP) { this.firP = firP; this.secP = secP; } public Builder thiP(int thiP) { this.thiP = thiP; return this; } public Builder fouP(int fouP) { this.fouP = fouP; return this; } public Builder fivP(int fivP) { this.fivP = fivP; return this; } public Second build() { return new Second(this); } } public static void main(String[] args) { Second second = new Second.Builder(1, 2).thiP(3).fouP(4).build(); } }
SupBuilder是附加的，根据项目，感觉需要就加上。这样，创建的时候用到了什么参数非常明显易读，最重要的易读，创建之后对象是不可变的。
怎么选择用静态工厂还是Builder，看创建对象时参数的多少。
第三条：用私有构造器或枚举类型强化Singleton属性
public enum Third { INSTANTCE }
这就能保证是一个单例，现在还没有真正领悟到枚举为什么好，用了枚举就不能定义成员了。
第四条：通过私有构造器强化不可实例化的能力
在项目中经常会有一些Util类中只包含静态方法和静态域的类，这些通常不需要实例化，实例化与不实例化也没有什么区别。但是在没有显示的构造器的情况下会默认的提供一个公有的构造器，就导致外部可以实例化这个类。如果把这个类设计成抽象类来防止实例化(抽象类和接口不能实例化)，会给其他人错觉这个类是面向继承设计的。我们只需要在这个类中提供一个私有构造器，为了避免类内部会调用这个构造器，可以抛异常，但最好的做法是在上面添加注释：
// Noninstantialble util class public class Fourth { private Fouth(){} }
注意：这样做了之后就无法被其他类继承了，因为没提供可调用的构造器。
第五条：避免创建不必要的对象
最简单的错误做法：
String s = new String("word"); // nerver do this String s = "word";
如果只是简单的想要一个String对象，别用new。
对于已知不会改变的可变对象也可以重用：
// wrong
private final Date date = new Date(); public int check() { Calendar calendar = Calendar.getInstance(); calendar.set(2000, Calendar.JANUARY, 1); Date startDate = calendar.getTime(); calendar.set(2017, Calendar.JANUARY, 1); Date endDate = calendar.getTime(); if (date.getTime() > startDate.getTime() && date.getTime() < endDate.getTime()) { return 1; } return 0; }
正确的做法：
private final Date date = new Date(); private static final Date startDate; private static final Date endDate; static { Calendar calendar = Calendar.getInstance(); calendar.set(2000, Calendar.JANUARY, 1); startDate = calendar.getTime(); calendar.set(2017, Calendar.JANUARY, 1); endDate = calendar.getTime(); } public int check() { if (date.getTime() > startDate.getTime() && date.getTime() < endDate.getTime()) { return 1; } return 0; }
没修改的做法在compare方法中，没进一次方法就会创建一个Calendar对象，两个Date对象。修改后的只会在实例化类的时候分别创建出来，在方法中不断的重用。上面的做法对于创建实例后经常调用compare方法的程序，性能会有很大的提高。还有一点，如果类被实例化了，但是compare方法从来不会被调用，可以做到延迟加载，在用到compare方法的时候才去实例化，但是不建议这样做，这样会增加代码的复杂性。
现在java提供自动装箱的操作，自动装箱使基本类型和自动装箱类型变的模糊起来。看下面的代码：
Long sum = 0L; for (int i = 0; i < Integer.MAX_VALUE; i++) { sum += i; } System.out.println(sum);
没进行一次+=操作，就会将根据long的数值重新生成一个Long，在进行下一次+=的时候，将Long转成long。会创建很多多余的对象。这里将Long类型的sum定义成long类型，效率就很提高很多。
这里说的不要创建多余对象并不是说尽量不创建对象，这里只是对于可以重用的对象只建一个然后不端重用。对于经常变的对象，不用考虑这点。
第六条：消除过期的对象
第七条：避免使用终结方法（finalizer）
在《深入了解java虚拟机》中有类似的内容。不在重复。
原文：http://www.cnblogs.com/badboyf/p/6282359.html