Effective.Java第1-11条

1. 考虑使用静态工厂方法替代构造方法

　　一个类可以提供一个公共静态工厂方法，它只是返回类实例的静态方法。例如JDK的Boolean的valueOf方法:

public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>
{
    public static final Boolean TRUE = new Boolean(true);

    public static final Boolean FALSE = new Boolean(false);

    public Boolean(boolean value) {
        this.value = value;
    }

    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }
...
}

　　静态工厂方法与设计模式中的工厂方法模式不同。

优点:

(1)静态工厂方法不像构造方法，它们有名字，语义清晰

(2)静态工厂方法不需要每次调用时都创建对象。例如返回静态对象，避免不必要的创建对象。

(3)静态工厂可以返回其返回类型的任何子类型的对象。

(4)其返回类型可以根据参数的不同而不同，比如EnumSet类的下面方法:

    public static <E extends Enum<E>> EnumSet<E> copyOf(Collection<E> c) {
        if (c instanceof EnumSet) {
            return ((EnumSet<E>)c).clone();
        } else {
            if (c.isEmpty())
                throw new IllegalArgumentException("Collection is empty");
            Iterator<E> i = c.iterator();
            E first = i.next();
            EnumSet<E> result = EnumSet.of(first);
            while (i.hasNext())
                result.add(i.next());
            return result;
        }
    }

(5)在编写包含该方法的类时，返回的对象的类不需要存在。这种灵活的静态工厂方法构成了服务提供者框架的基础。比如Java数据库连接JDBC。由对应的厂商提供具体的实现类。

缺点:

(1)如果类不含public或protected的构造方法，将不能被继承。

(2)与其它普通静态方法没有区别，没有明确的标识一个静态方法用于实例化类。也就是API不是非常全。所以，一般一个静态工厂方法需要有详细的注释，遵守标准的命名。如下:

from——A 类型转换方法，它接受单个参数并返回此类型的相应实例，例如：Date d = Date.from(instant);
of——一个聚合方法，接受多个参数并返回该类型的实例，并把他们合并在一起，例如：Set faceCards = EnumSet.of(JACK, QUEEN, KING);
valueOf——from 和 to 更为详细的替代 方式，例如：BigInteger prime = BigInteger.valueOf(Integer.MAX_VALUE);
instance 或 getinstance——返回一个由其参数 (如果有的话) 描述的实例，但不能说它具有相同的值，例如：StackWalker luke = StackWalker.getInstance(options);
create 或 newInstance——与 instance 或 getInstance 类似，除了该方法保证每个调用返回一个新的实例，例如：Object newArray = Array.newInstance(classObject, arrayLen);
getType——与 getInstance 类似，但是如果在工厂方法中不同的类中使用。Type 是工厂方法返回的对象类型，例如：FileStore fs = Files.getFileStore(path);
newType——与 newInstance 类似，但是如果在工厂方法中不同的类中使用。Type 是工厂方法返回的对象类型，例如：BuweredReader br = Files.newBuweredReader(path);
type—— getType 和 newType 简洁的替代方式，例如：List litany = Collections.list(legacyLitany);

2. 当构造方法参数过多时考虑构造模式

比如一个User，有好多属性，但是只有ID是必须有的，其他属性可有可无。如下：

package cn.qlq.builder;

public class User {

    // 必须字段
    private int id;

    private String name;
    private String sex;
    private String job;
    private String health;
    private String BMI;
    private int height;
    private int weight;

    public User() {
        super();
    }

    public User(int id, String name, String sex, String job, String health, String bMI, int height, int weight) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.job = job;
        this.health = health;
        BMI = bMI;
        this.height = height;
        this.weight = weight;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getHealth() {
        return health;
    }

    public void setHealth(String health) {
        this.health = health;
    }

    public String getBMI() {
        return BMI;
    }

    public void setBMI(String bMI) {
        BMI = bMI;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", sex=" + sex + ", job=" + job + ", health=" + health + ", BMI="
                + BMI + ", height=" + height + ", weight=" + weight + "]";
    }

}

当我们设置几个属性的时候可以通过构造方法进行创建，但是比如我们只想设置一些属性，其他属性没用，我们可能会写成空值，这样的代码阅读起来很难懂,属性更多的时候更加难以阅读:

User user = new User(1, "张三", "", "", "", "", 0, 0);

也有可能通过setter进行设值，如下:(属性更多的时候需要更多的setter)

        User user = new User();
        user.setId(1);
        user.setName("xxx");
        user.setBMI("XXX");
　　　　...

解决办法:采用建造模式 + 流式写法

　　由于是用Builder模式来创建某个对象，因此就没有必要再定义一个Builder接口，直接提供一个具体的建造者类就可以了。
　　对于创建一个复杂的对象，可能会有很多种不同的选择和步骤，干脆去掉“导演者”，把导演者的功能和Client的功能合并起来，也就是说,Client这个时候就相当于导演者，它来指导构建器类去构建需要的复杂对象。

package cn.qlq.builder;

public class UserBuilder {

    private User user = new User();

    /**
     * 构造方法确保ID必有
     * 
     * @param id
     */
    public UserBuilder(int id) {
        user.setId(id);
    }

    UserBuilder name(String name) {
        user.setName(name);
        return this;
    }

    UserBuilder sex(String sex) {
        user.setSex(sex);
        return this;
    }

    UserBuilder job(String job) {
        user.setJob(job);
        return this;
    }

    UserBuilder health(String health) {
        user.setHealth(health);
        return this;
    }

    UserBuilder BMI(String BMI) {
        user.setBMI(BMI);
        return this;
    }

    UserBuilder height(int height) {
        user.setHeight(height);
        return this;
    }

    UserBuilder weight(int weight) {
        user.setWeight(weight);
        return this;
    }

    public User build() {
        if (user.getId() == 0) {
            throw new RuntimeException("id必须设置");
        }

        return user;
    }

}

客户端代码:

package cn.qlq.builder;

public class MainClass {

    public static void main(String[] args) {
        UserBuilder userBuilder = new UserBuilder(2);
        User user = userBuilder.name("张三").BMI("xxx").health("健康").build();
        System.out.println(user);
    }

}

　　这样的代码读起来也舒服，语义也更好理解。

3.使用私有构造方法或枚举类实现Singleton属性

(1)使用静态工厂方法实现

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
。。。
}

　　如果需要防御通过反射创建对象，可以在构造方法中判断，当currentRuntime != null 的时候禁止创建(抛出一个RuntimeException).

(2)枚举类实现

package cn.qlq.thread.fifteen;

/**
 * 枚举实现单例模式
 * 
 * @author Administrator
 *
 */
public enum Singleton_6 {

    instance;

    private Singleton_6() {
        System.out.println("调用构造方法");
    }

    public Singleton_6 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        System.out.println(Singleton_6.instance.getInstance());
    }
}

4.使用私有构造方法执行非实例化

　　我们经常会使用一些只包含静态方法和静态属性的类。这样的类获得了不好的名声，因为有些人滥用这些类而避免以面向对象的方式思考，但是它们确实有着特殊的用途。比如说工具类或者说常量工具类。

　　JDK8开始，接口也允许有默认的静态方法和default方法。

　　这样的类不允许被实例化:一个实例是没有意义的。然而，在没有显示构造方法的情况下，编译器提供了一个公共的、无参的默认构造方法。因为当类不包含显示构造方法的时候，才会生成一个默认的构造方法，因此可以通过包含一个私有构造方法来实现类的非实例化:

public class DocUtils {

    // 静止实例化
    private DocUtils() {
        throw new RuntimeException();
    }

}

 

 5.  依赖注入优于硬链接资源

　　许多类依赖一个或者多个底层资源。如：拼写检查类依赖于一个字典类.

常见一：将此类实现为静态实用工具类

public class SpellChecker {
    private static final Lexicon dictionary = ...;
    private SpellChecker() {} // Noninstantiable
    public static boolean isValid(String word) { ... }
        public static List suggestions(String typo) { ... }
    }

}

常见二:实现为单例

public class SpellChecker {
    private final Lexicon dictionary = ...;

    private SpellChecker(...) {}
    public static INSTANCE = new SpellChecker(...);

    public boolean isValid(String word) { ... }
    public List<String> suggestions(String typo) { ... }
}

　　上面两种做法都令人不满意，因为它们假设只有一本字典。

　　最高效的做法是使 dictionary  属性设置为非final，并且通过一个方法改变此属性，以实现支持多个字典。

　　依赖项注入（dependency injection）的一种形式：字典是拼写检查器的一个依赖项，当它创建时被注入到拼写检查器中。

// Dependency injection provides flexibility and testability
public class SpellChecker {
    private final Lexicon dictionary;

    public SpellChecker(Lexicon dictionary) {
        this.dictionary = Objects.requireNonNull(dictionary);
    }

    public boolean isValid(String word) { ... }
    public List<String> suggestions(String typo) { ... }
}

6.  避免创建不必要的对象

　　每次需要时重用一个对象而不是创建一个新的功能相同的对象。常用的如静态工厂方法模式，如:

    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

例如:

String s = new String("str");

　　每次执行都会创建一个String对象，而这些对象并不是必须的，建议改为:

String s = "str";

　　优先使用基本类型而不是装箱的基本类型，也要注意无意识地装箱。

7.  消除过期的对象引用

　　简单的理解为:一旦对象引用过期，将其设为null。一个好处就是如果之后被错误的引用会抛出NPE。

8.  避免使用Finalizer和Cleaner机制

　　Java9中用Cleaner代替了Finalizer，但是Finalizer仍被保留使用。

　　注意不能把Java中的Finalizer和Cleaner当成c++的析构函数。在c++中，析构函数是正确的回收对象相关资源方式，是与构造方法对应的。在Java中，当一个对象不可达时，垃圾收集器回收与对象相关联的存储空间，不需要开发人员做额外工作。C++析构函数也被用来回收其他内存资源。Java中，try-finally或者try-with-resources用于此目的。

　　Finalizer和Cleaner的一个缺点是不能保证他们能够及时地执行。也就是说当对象引用不可达时，这两个方法的执行时间是不固定的，所以不应该做任何业务相关代码。

　　不能相信System.gc() 和 System.runFinalization() 等方法，他们也只是简单的通知进行GC，并不会马上GC。

9.  使用 try-with-resources语句替代 try-finally 语句

　　关闭流的方式有很多种方式，一般都是手动关闭，比如 InputStream、OutputStream和Java.sql.Connection。

package cn.qlq;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class MainClass {

    public static void main(String[] args) {
        File file = new File("/usr/test.txt");
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(file);
            outputStream = new FileOutputStream(file);
            // 使用流
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

再次升级变为如下方式，有点类似于IOUtils的方法:

package cn.qlq;

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class MainClass {

    public static void main(String[] args) {
        File file = new File("/usr/test.txt");
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(file);
            outputStream = new FileOutputStream(file);
            // 使用流
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            closeQuietly(outputStream);
            closeQuietly(inputStream);
        }

    }

    private static void closeQuietly(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                // ignored
            }
        }
    }

}

　　上面代码比较冗余，而且不易阅读，Java7引入了 try-with-resources。代码阅读比较简单，而且提供了更好的诊断。如下:(建议这种写法，当然catch代码块可以不写，一般用于记录一些信息)

    public static String readValue(String filePath, String defaultValue) {
        File file = new File("/usr/test.txt");
        try (InputStream inputStream = new FileInputStream(file);
                OutputStream outputStream = new FileOutputStream(file)) {

            // 读取文件返回值
            return "";
        } catch (Throwable e) {
            // 记录日志
            return defaultValue;
        }
    }

10.  重写equals()方法时遵守通用约定

按照约定，equals方法要满足以下规则。

自反性:  对于任何非空引用x，x.equals(x) 一定是true

对称性: 对于非空引用x和y， x.equals(y)  和  y.equals(x)结果一致

传递性:  a 和 b equals , b 和 c  equals，那么 a 和 c也一定equals。

一致性: 对于任何非空引用x和y，如果在equals比较中使用的信息没有被修改，则x.equals(y) 的多次调用必须始终返回true或者false。

非空性: 对于任何非空引用x，  x.equals(null) 一定是false

同时，也有一些提醒，比如:

(1)重写了euqals方法的对象必须同时重写hashCode()方法。

(2)在equals方法中，不要将参数的Object类型换成其他类型。

编写高质量equals()方法的建议：

（1）使用==运算符检查参数是否为该对象的引用。如果是，返回ttrue。这只是一种性能优化。

（2）使用 instanceof 来检查参数是否是正确的类型，如果不是返回false。

（3）参数转换为正确的类型。

（4）对于每个类的重要属性，在equals中进行比较。

　　对于类型为非float或double的基本类型，使用==运算符比较；对于对象引用属性，递归地调用equals方法；对于float基本类型的属性，使用Float.compare(float, float)方法；对于double基本类型的属性，使用Double.compare(double, double)。

　　在很多情况下，不要重写equals方法，从Object继承的完全是想要的。如果确实重写了equals()方法，那么一定要比较这个类的所有属性，并且遵守上面五条规则。

　　在比较两个对象是否是同一个对象的时候用equals，不用==。

11.  重写了euqals方法的对象必须同时重写hashCode()方法。

　　这个方法返回对象的散列码，返回值是int类型的散列码。对象的散列码是为了更好的支持基于哈希机制的Java集合类，例如 Hashtable, HashMap, HashSet 等。

　　等价的(调用equals返回true)对象必须产生相同的散列码。不等价的对象，不要求产生的散列码不相同。

　　假设只重写equals而不重写hashcode，那么类的hashcode方法就是Object默认的hashcode方法，由于默认的hashcode方法是根据对象的内存地址经哈希算法得来的,所以会导致equals相等的两个对象的hasCode()不一定相等，违反了上面的约定。

　　

 例如:使用commons-lang包自带的工具类编写equals和hasCode方法:

package cn.qlq;

import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;

public class User implements Cloneable {

    private int age;
    private String name, sex;

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (obj == this) {
            return true;
        }

        if (!(obj instanceof User)) {
            return false;
        }

        final User tmpUser = (User) obj;
        return new EqualsBuilder().appendSuper(super.equals(obj)).append(name, tmpUser.getName()).isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder().append(name).toHashCode();
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + ", sex=" + sex + "]";
    }

}