第 3 次读 Effective Java，这 58 个技巧值！

2020-11-23 00:00:00 函数对象方法子类构造

来源：Dong GuoChao

《Effective Java》Java名著，必读。如果能严格遵从本文的原则，以编写API的质量来苛求自己的代码，会大大提升编码素质。

以下内容只记录了我自己整理的东西，还是建议读原文。为了聚焦知识点，一些说明故意忽略掉了。相当于是一篇摘要。

1、考虑用静态工厂方法替代构造函数

例子：

Integer.valueOf(“1”)、Boolean.valueOf(“true”)等。

优势：

可读性高（方法名）
性能（不一定创建对象）
灵活性高

下面针对三个优势进行一些解读。

可读性高

new Point(x,y)和Point.at(x,y)、Point.origin()。构造函数只能看出两个参数，不知其意，后者更易理解。

性能

在某些情况下，可以事先进行实例化一些对象，调用时直接调用即可，不需要进行改变。比如，Boolean。

public final class Boolean implements Serializable, Comparable<Boolean> {
    // 预先设置两个对象
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

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

    public Boolean(String var1) {
        this(parseBoolean(var1));
    }

    // 工厂方法
    public static Boolean valueOf(boolean var0) {
        return var0?TRUE:FALSE; // 返回预先设置的对象，而不是创建对象
    }
    // 工厂方法
    public static Boolean valueOf(String var0) {
        return parseBoolean(var0)?TRUE:FALSE;
    }
    // ... other code
}

灵活性高

可根据具体情况，返回子类。相当于更强大的工厂。直接从父类获取到子类。尤其适用于工具类（提供各种API）。例子：Collections。

public class Collections {
    // 私有，典型工厂
    private Collections() {
    }

    public static final List EMPTY_LIST = new EmptyList<>();
    // 工厂方法
    public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
    }
    private static class EmptyList<E> extends AbstractList<E> implements RandomAccess, Serializable {
    // code
    }

    // 工厂方法
    public static <E> List<E> checkedList(List<E> list, Class<E> type) {
    // 根据具体情况，获取相应子类
        return (list instanceof RandomAccess ?
                new CheckedRandomAccessList<>(list, type) :
                new CheckedList<>(list, type));
    }

    // 子类1
    static class CheckedRandomAccessList<E> extends CheckedList<E> implements RandomAccess {
        CheckedRandomAccessList(List<E> list, Class<E> type) {
            super(list, type);
        }

        public List<E> subList(int fromIndex, int toIndex) {
            return new CheckedRandomAccessList<>(
                    list.subList(fromIndex, toIndex), type);
        }
    }

    // 子类2
    static class CheckedList<E> extends CheckedCollection<E> implements List<E> {
    // code
    }
}

2、多个构造函数时，考虑使用构造器

尤其在进行Android开发时，会碰到这种情况。通常是一个对象，具有多个成员变量可能需要初始化，常规方法，需要提供大量构造函数。例如：

// 非Android中的AlertDialog，便于说明问题，举个例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    private AlertDialog(){}
    public AlertDialog(int width, int height){ // 空白的警告框
         AlertDialog(width,height,null);
    }

    // 带标题的警告框
    public AlertDialog(int width, int height, String title){ // 带标题的警告框
        AlertDialog(width, height, title, "确定");
    }

    // 带标题的警告框，有确定按钮
    public AlertDialog(int width, int height, String title, String confirm){
        AlertDialog(width, height, title, confirm, null);
    }

    // 带标题的警告框，有确定按钮，取消按钮
    public AlertDialog(int width, int height, String title, String confirm, String denyText){
        // set every thing.
    }
}

有多种样式的警告框，为了调用方便，必须提供多个构造函数。否则用户在调用时，只能使用完整构造函数，容易犯错且无法进行阅读。极不灵活。如果采用另外一种方式，则可以解决，但会花费很多经历处理并发的情况:

// 非Android中的AlertDialog，便于说明问题，举个例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    public AlertDialog(){}// 空白的构造函数

    public void setWidth(int width){
        this.width = width;
    }
    // 其他set方法
}

调用时，通过调用各个参数的set方法进行设置。问题来了：

并发
无法进行参数校验。

例如，只创建了对象，设置了标题，却没有尺寸，相当于创建了一个没有尺寸的警告框。

在Android中，大量的控件都使用了构造器Builder。

// 非Android中的AlertDialog，便于说明问题，举个例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    // private
    private AlertDialog(){}

    // Builder中使用
    protected AlertDialog(Builder b){
        width = b.width;
        height = b.height;
        // .....
        if(width==||height==) throws new Exception("size must be set");
    }

    // 构造器
    public static class Builder {
        private int width;
        private int height;
        private String title;
        private String confirmText;
        private String denyText;

        // 注意：返回的Builder。
        public Builder setTitle(String title) {
            this.title = title;
            return this;
        }
        // 其他set...

        public AlertDialog build(){
            return AlertDialog(this);
        }
    }
}

于是，可以根据相应需求，进行相应设置，并在AlertDialog真正构造时，进行参数校验。就像这样：

new AlertDialog.Builder().setTitle("提示").build();

上述例子，会成功抛出异常。

3、用私有化构造器或者枚举型强化Singleton。

Singleton指多会被实例化一次的类。通常情况下，以前的做法是没有问题的。但是在某些情况，通过使用反射的相关知识访问private的构造函数，破坏Singleton。

public class Elvis{
    // 注意，公有final对象
    public static final Elvis INSTANCE = new Elvis();
    private Elvis(){}
}

另一种情况，在序列化的过程中，反序列化得到的对象已经不再是以前的对象（破坏了Singleton），这种情况下，可以通过单元素枚举型处理。

public enum Elvis{
    INSTANCE;
    // some methods
}

4、通过私有化构造器强化不可实例化的能力

有一些工具类，仅仅是提供一些能力，自己本身不具备任何属性，所以，不适合提供构造函数。然而，缺失构造函数编译器会自动添加上一个无参的构造器。所以，需要提供一个私有化的构造函数。为了防止在类内部误用，再加上一个保护措施和注释。

public class Util{
    private Util(){
        // 抛出异常，防止内部误调用
        throw new AssertionError();
    }
}

弊端是无法对该类进行继承（子类会调用super()）。

5、避免创建不必要的对象

对象的重用
昂贵的对象，使用对象池
廉价的对象，慎用对象池。

现代JVM对廉价对象的创建和销毁非常快，此时不适于使用对象池。

6、消除过期的对象引用

以下三种情况可能会造成内存泄露：

自己管理的内存（数组长度减小后，pop出的对象容易导致内存泄漏）
缓存
监听和回调

自己管理的内存

对于自己管理的内存要小心，比如：

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

    public Stack(){
         elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e){
        ensureCapacity();
        elements[size++]=e; // allocate新的堆内存和栈内存
    }

    public Object pop(){
        if(size==) throw new EmptyStackException();
        return element[--size]; // pop出element[size]，该对象不再有效。内存泄漏原因。
    }

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

弹出的对象不再有效，但JVM不知道，所以会一直保持该对象，造成内存泄露。

解决：

public Object pop(){
        if(size==) throw new EmptyStackException();
        elements[size] = null; // 等待回收
        return element[--size];
    }

缓存

缓存的对象容易被程序员遗忘，需要设置机制来维护缓存，例如不定期回收不再使用的缓存（使用定时器）。某些情况下，使用WeakHashMap可以达到缓存回收的功效。注，只有缓存依赖于外部环境，而不是依赖于值时，WeakHashMap才有效。

监听或回调

使用监听和回调要记住取消注册。确保回收的好的实现是使用弱引用（weak reference），例如，只将他们保存成WeakHashMap的键。

7、避免显示调用GC

Java的GC有强大的回收机制，可以简单的记住：不要显示调用finalizer。可以这样理解：

jvm是针对具体的硬件设计的，然而程序却不是针对具体硬件设计的，所以，java代码无法很好的解决gc问题（因为他具有平台差异化）。另外，finalizer的性能开销也非常大，从这个角度上考虑也不应该使用它。

8、覆盖equals方法请遵守通用约定

自反性。x.equals(x) == true
对称性。当前仅当y.equals(x)==true时，x.equals(y)==true
传递性。if(x.equals(y)&&y.equals(z))，y.equals(z)==true
一致性。
非空性。x.equals(null)==false

9、覆盖equals方法时总要覆盖hashCode

为了保证基于散列的集合使用该类（HashMap、HashSet、HashTable），同时，也是Object.hashCode的通用约定，覆盖equals方法时，必须覆盖hashCode。

10、始终覆盖toString

Object的toString方法的通用约定是该对象的描述。注意覆盖时，如果有格式，请备注或者严格按照格式返回。

11、谨慎覆盖clone

12、考虑实现Comparable接口

13、使类和成员的可访问性小化

目的是解耦。简单来讲，使用修饰符的优先级从大到小，private>protected>default(缺省)>public。如果在设计之初，设计为private修饰符后，在之后的编码过程如果不得不扩大其作用于，应该先检查是否设计的确如此。

子类覆盖超类，不允许访问级别低于超类的访问级别。（超类的protected，子类覆盖后不能改为default）。

成员变量决不允许是公有的。一旦设置为公有，则放弃了对他处理的能力。这种类并不是线程安全的。即使是final的，也不允许。除非希望通过public static final来暴露常量。成员变量总是需要使用setter和getter来维护。有一个例外：长度非零的数组。这是安全漏洞的一个根源。

public Object pop(){
        if(size==) throw new EmptyStackException();
        elements[size] = null; // 等待回收
        return element[--size];
    }

改进：

private static final Thing[] PRIVATE_VALUES = {...}
// 此时获取到的才是“常量”
public static final List<Thing> VALUS =
    Collections.unmodifiableList(Arrays.asList(PRIVATE_VALUES))

另一种：

private static final Thing[] PRIVATE_VALUES = {...}
// 此时获取到的才是“常量”
public static final Thing[] values(){
    return PRIVATE_VALUES.clone();
}

14、在公有类中使用访问方法而非公有成员变量（类似13）

15、使可变性小化

16、复合优先于继承

继承有利于代码复用，但是尽可能不要进行跨包的继承。包内的继承是的设计方式，一个包里的文件处在同一个程序员的控制之下。但是继承有其局限性：子类依赖于超类。超类一旦发生更改，将可能破坏子类。并且，如果超类是有缺陷的，子类也会得“遗传病”。

复合，即不扩展已有的类，而是在的类中新增一个现有类的。相当于现有类作为一个组建存在于新类中。如此，将只会用到需要用到的东西，而不表现现有类所有的方法和成员变量。新类也可以称为“包装类”，也就是设计模式中的Decorate模式。

17、要么就为继承而设计，并提供文档说明，要么就禁止继承

18、接口优于抽象类

19、接口只用于定义类型

20、类层次优先于标签类

21、用函数对象表示策略

函数参数可以传入类似listener的对象，目的是使用listener中的方法。如果使用匿名的参数，每一次调用会创建新的对象。可以将listener声明为成员变量，每次都复用同一个对象，并且可以使用静态域（static变量）。比如String类的CASE_INSENSITIVE_ORDER域。

22、优先考虑静态类成员

嵌套类的目的应该只是为了他的外围类提供服务，如果以后还可能用于其他环境中，则应该设计为顶层类。静态类相当于一个普通的外部类，只是恰好声明在了一个类内部。通常的用户是：Calculator.Operation.PLUS等。和普通类的区别只是，在PLUS前，有了2个前缀，来表明其含义。而非静态类必须存在于外部类对象中。不要手动在外部创建一个内部非静态类对象，创建的过程是：instance.New MemberClass()。这非常奇怪。

如果成员类不需要访问外围类，则需要添加static，是他成为静态成员类，否则每个实例都将包含一个额外指向外围对象的引用。将会影响垃圾回收机制。

23、应指定泛型的具体类型，而不是直接使用原生类型。

例如，应该指定List，而不建议直接使用List。

24、消除非首检警告

在使用IDE进行编码时，强大的IDE都会在你编码过程中提示warning，需要尽可能的消除warning，至少，应该小心这些warning。慎用SuppresWarning，如果IDE提示你可以通过添加该注解解决掉warning，请不要那么做。如果实在要使用，请添加注释说明原因。

25、列表优先于数组

类比泛型，数组是有一定缺陷的。List和List是没有关系的，而Sub[]是Super[]的子类。

// Fails at runtime
Object[] objectArray = new Long[1];
objectArray[] = "I don't fit in"; // throw exception

// won't compile
List<Object> ol = new ArrayList<Long>(); // Incompatible *
ol.add("I don't fit in");

从代码中可以看到，使用泛型，会提前发现错误。

26、优先考虑泛型

27、优先考虑泛型方法

28、利用有限制通配符来提升API的灵活性

PECS，producer-extends，consumer-super。

//public class Stack<E>{
// public Stack();
// public void push(E e);
// public E pop();
// public boolean isEmpty();
//}

public void pushAll(Iterator<? extends E> src){
    for(E e : src)
        push(e);
}

public void popAll(Collection<? super E> dst){
    while(!isEmpty()){
        dst.add(pop());
    }
}

// Get and Put Principle

所有comparable和comparator都是消费者（Consumer）。

29、优先考虑类型安全的异构容器

30、用enum代替int常量

public enum Apple { FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

枚举型在java中非常强大，当需要一组固定常量时，使用enum比int好很多。比如代码可读性，安全性等。

31、enum用实例域代替序数

// bad solution
public enum Ensemble {
    SOLO, DUET, TRIO, QUARTET, QUINTET,
    SEXTET, SEPTET, OCTET, NONET, DECTET;

    public int numberOfMusicians() { return ordinal() + 1; }
}
//

// improvement
public enum Ensemble {
    SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
    SEXTET(6), SEPTET(7), OCTET(8), NONET(9), DECTET(10), TRIPLE_QUARTET(12);

    private final int numberOfMusicians;
    Ensemble(int size) { this.numberOfMusicians = size; }
    public int numberOfMusicians() { return numberOfMusicians; }
}

永远不要像种的方式，利用序数访问enum，需要在构造函数中使用参数来初始化。

32、用EnumSet代替位域

public class Text{
    public static final int STYLE_BOLD = 1 << ; // 1
    public static final int STYLE_ITALIC = 1 << 1; // 2
    public static final int STYLE_UNDERLINE = 1 << 2; // 4
    public static final int STYLE_STRIKETHROUGH = 1 << 3; // 8

    public void applyStyles(int styles){
        // ...
    }
}

//
text.applyStyles(STYLE_BOLD | STYLE_ITALIC);

以上叫做位图法，但是有更好的方案来传递多组常量——EnumSet。

public class Text{
    public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }

    // 注意此处，使用的是Set而不是EnumSet
    public void applyStyles(Set<Style> styles){
        // ...
    }
}

//
text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

33、用EnumMap代替序数索引

任何时候都不要使用enum的ordinal()方法。

34、用接口模拟可伸缩的枚举

35、注解优先于命名模式

36、坚持使用Override注解

38、检查参数的有效性

公有方法检查参数，参数异常需要跑出Exception。私有方法利用断言assertion检查参数。

39、必要时进行保护性拷贝

假设类的客户端会尽其所能来破坏这个类的约束条件，因此你必须保护性的设计程序。以下是一个不可变类的设计。

public Period(Date start, Date end){
    this.start = new Date(start); // 使用了值的拷贝，没有使用原对象（指针）
    this.end = new Date(end);
    if(this.start.compareTo(this.end)>)
        throw new IllegalArgumentException(start + " after " + end)
}

注意：保护性拷贝是在检查参数之前进行的，防止多线程的影响。不要使用clone方法进行保护性拷贝。

以上方法防御了传入参数的修改，但是对于get方法获取到的对象，仍然可以被修改，通过以下方法可以防止这种攻击。

public Date start(){
    return new Date(start);
}

public Date end(){
    return new Date(end);
}

40、谨慎设计方法签名

41、慎用重载

42、慎用可变参数

43、返回0长度的数组或者集合，而不是null

null一般用于表示没有被初始化或处理，如果方法返回了null，则需要在上层做更多的处理，以防止NPE。

44、为所有导出的API元素编写文档注释

正确的javadoc文档，需要每个被导出的类、接口、构造器、方法和域之前增加文档注释。注释应该是对实现透明的，只需要简洁的描述它和客户端之间的约定。并且，还应该附上该方法的副作用。

45、将局部变量的作用域小化

46、for-each优先于for循环

for-each规避掉了for循环的index变量的引用，通常来说它是不必要的——会增加引入错误的风险，并且风险一旦发生，很难被发现。不过有三种情况下，无法使用for-each（注：在jdk1.8中已经很好的解决了这些问题）。

过滤
转换
平行迭代

48、如果需要的答案，请避免使用float和double

float和double是执行的二进制浮点运算，目的是在广泛数值范围上使用的快速近似计算而设计的。然而他们并没有提供完全的计算（实际应用中，经常会碰到出现x.99999等结果）。尤其是，在进行货币计算时，他们并不适用。比如：

System.out.println(1.03-.42);

得到的结果将是：0.610000000001。

为了解决这个问题，需要使用BigDecimal。然而这也有一些问题，相对于普通的运算，它显得更加麻烦，而且也更慢。通常来说后一个缺点可以忽略，但是前者可能会让人很不舒服。有一种做法是将需要处理的数值*10(或更多），使用int进行计算，不过需要你自己处理四舍五入等操作。

49、基本类型优先于装箱基本类型

基本类型只有值，装箱类具有与他们值不同的同一性。

基本类型只有功能完备的值，装箱类还具有非功能值：

null。

所以你可能会碰到NPE

基本类型省空间省时间

50、如果有更的类型，请避免使用字符串

字符串不适合代替其他值的类型。

例如：int，boolean等

不适合代替枚举类型（第30条）
不适合聚集类型

51、当心字符串连接的性能

操作符“+”可以将多个字符串进行连接。但是在大规模使用“+”的情况下，连接n个字符串的开销是n的平房级时间。这是由于字符串的不可变性导致的。在这种情况下请使用StringBuilder进行连接。

52、通过接口引用对象

53、接口优先于反射机制

使用反射机制会带来以下的问题：

丧失了编译期类型检查
代码笨拙冗长
性能损失

反射基本上只适合用在编写组件时、代码分析器、RPC等场景下使用。在使用反射机制时，如果可能，尽可能只通过反射机制实例化对象，而访问方法时，使用已知的接口或者超类。

54、谨慎使用JNI

55、谨慎进行优化

很多计算上的过失都被归咎于效率（没有必要达到的效率），而不是任何其他原因——甚至包括盲目的做傻事。

——William A. Wulf

不要去计较效率上的一些小小的得失，在97%的情况下，不成熟的优化才是一切问题的根源。

——Donald E. Knuth

在优化方面，我们应该遵守两条规则：

规则1:不要进行优化。

规则2（仅针对专家）：还是不要进行优化——也就是说，在你还没有清晰的优化方案前，请不要进行优化。

——M. A. Jackson

这些格言比java的出现还要早20年。他们讲述了一个关于优化的深刻事实：优化的弊大于利。

要努力编写好的程序，而不是快的程序。低耦合的重要性远远大于性能。当程序编写得足够低耦合后，通过工具发现了性能瓶颈的代码块，才可以保证对其的修改不影响任何外部环境。

56、遵守普遍的命名规则

57、只针对异常情况才使用异常

不要尝试通过异常机制来做正常代码应该做的事情，比如，检查数组下标。

jvm很少对异常进行优化，因为它只用于不正常的情况。并且，如果你将代码放入try-catch代码块，jvm就丧失了本来可以对它进行的优化。

58、对于可恢复的情况使用受检异常，对于编程错误的情况使用运行时异常

如果期望调用者适当的恢复，则需要使用受检异常，强迫调用者食用try-catch代码块，或者将他们抛出去

当调用发生前提违例——违反约定的情况时，使用运行时异常，这个时候程序已经无法再执行下去了。

例如调用数组的-1索引。

近有有不少老铁在后台留言说，想进大厂，但是算法不好。近我整理了一份刷题实录，这份刷题实录，也让我进了心仪的大厂。现在开放分享给大家。希望对大家有所帮助。

任何的算法题，如同写作文一样，都有一些模板可以套用的。比如面试常考的DP（动态规划），难的是一些关键点是否能想清楚。比如你能写出动态转移方程，这题基本上就可以AC了。

整个刷题实录内容，包括 双子针、动态规划、二分查找、贪心算法、深度优先搜索、字符串、递归、字典树、排序、链表等相关专题内容。图文并茂，附有刷题答案源码。

刷题任务的题目，是根据题目的类型来汇总的，总结了八个类别，每个类别下面也总结了5个左右的题型，帮助大家分门别类的突破，所以刷起来相对会更有重点和针对性。如果从头到尾的刷，每周按顺序刷42题，很容易让自己坚持不下来，也会觉得很枯燥。所以在制定计划的时候可以让这个计划变得更“有趣"和针对性，让它看起来更容易实现一点，才会更容易坚持。

相关文章

第 3 次读 Effective Java，这 58 个技巧值！

1、考虑用静态工厂方法替代构造函数

例子：

优势：

可读性高（方法名）

性能（不一定创建对象）

灵活性高

可读性高

性能

灵活性高

2、多个构造函数时，考虑使用构造器

3、用私有化构造器或者枚举型强化Singleton。

4、通过私有化构造器强化不可实例化的能力

5、避免创建不必要的对象

6、消除过期的对象引用

自己管理的内存

缓存

监听或回调

7、避免显示调用GC

8、覆盖equals方法请遵守通用约定

9、覆盖equals方法时总要覆盖hashCode

10、始终覆盖toString

11、谨慎覆盖clone

12、考虑实现Comparable接口

13、使类和成员的可访问性小化

14、在公有类中使用访问方法而非公有成员变量（类似13）

15、使可变性小化

16、复合优先于继承

17、要么就为继承而设计，并提供文档说明，要么就禁止继承

18、接口优于抽象类

19、接口只用于定义类型

20、类层次优先于标签类

21、用函数对象表示策略

22、优先考虑静态类成员

23、应指定泛型的具体类型，而不是直接使用原生类型。

24、消除非首检警告

25、列表优先于数组

26、优先考虑泛型

27、优先考虑泛型方法

28、利用有限制通配符来提升API的灵活性

29、优先考虑类型安全的异构容器

30、用enum代替int常量

31、enum用实例域代替序数

32、用EnumSet代替位域

33、用EnumMap代替序数索引

34、用接口模拟可伸缩的枚举

35、注解优先于命名模式

36、坚持使用Override注解

38、检查参数的有效性

39、必要时进行保护性拷贝

40、谨慎设计方法签名

41、慎用重载

42、慎用可变参数

43、返回0长度的数组或者集合，而不是null

44、为所有导出的API元素编写文档注释

45、将局部变量的作用域小化

46、for-each优先于for循环

48、如果需要的答案，请避免使用float和double

49、基本类型优先于装箱基本类型

50、如果有更的类型，请避免使用字符串

字符串不适合代替其他值的类型。

51、当心字符串连接的性能

52、通过接口引用对象

53、接口优先于反射机制

54、谨慎使用JNI

55、谨慎进行优化

56、遵守普遍的命名规则

57、只针对异常情况才使用异常

58、对于可恢复的情况使用受检异常，对于编程错误的情况使用运行时异常