根据 JDK Tutorial 的描述，除非在执行 try 或 catch 代码时线程被中断或 JVM 退出，finally 中的逻辑始终会执行。因此 finally 关键字常被用于释放资源，防止程序出现异常时出现资源泄露。本文主要探讨其在 JVM 层面的实现原理，以及 synchronized 关键字在类似场景的处理手段。首先来看一段简单的 try-finally 代码

1
2
3
4
5
6
7

public void testWithTryFinally() {
  try {
    System.out.println("try");
  } finally {
    System.out.println("finally");
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class NPESolution {
    
    public void withIf(Person person){
        if(person != null){
            // ...
        }
        // ...
    }

    public void withSpringAssert(Person person){
        Assert.isTrue(person != null, "person must be not null.");
        // ...
    }

    public void withOptional(Person person){
        Optional<Person> personOptional = Optional.ofNullable(person);
        // ...
    }

    public void withJsr305Annotation(@Nonnull Person person){
        Optional<Person> personOptional = Optional.of(person);
        // ...
    }
}

上述的代码是我在日常用于避免空指针（NPE）的常用方式，很长时间内我都热衷于断言（Assert）这类防御性编程方式，防御性编程可以有效的保证方法的输入条件，并在毫无意义的边界情况能够给出有效的提示，何乐而不为呢？事实上防御性编程也确实是一种非常推荐的方式，并且其在 Spring 源码中随处可见。而 JDK8 的 Optional 是否会是一种更优雅的方式呢？亦或许，另有它人？

在 Java 中，在一个类中声明另一个类则称为嵌套类，被声明为 static 的嵌套类称为静态嵌套类（static nested classes ），与之相对的非静态嵌套类被称为内部类(（inner classes ）

• 非静态嵌套类每个实例都包含一个额外指向外围对象的引用，换句话说，要实例化一个非静态嵌套类必须首先实例化外部类

• 静态嵌套类独立于外部类实例，可以看作嵌套在一个顶级类中的顶级类。因此，如果嵌套类不要求访问外部类的实例变量或方法，就要始终把 static 修饰符放在它的声明中，使它成为静态嵌套类。（如果该嵌套类不作为基类，那么更适合同时加上 final 修饰符）。JDK1.8 源码可见各种这样的设计，如 ReentrantLock 中

  1 2 3

  static final class NonfairSync extends Sync { ... }

我们从四个方面来更详细的讨论它们的区别：

• 嵌套类访问外部类的范围

• 嵌套类本身定义变量的范围

• 实例化

• 同名覆盖

无限制通配符

无限通配符即： <?>，主要在不确定或不关心实际参数类型时使用，如：

1
2
3

public boolean removeAll(Collection<?> c){
    ...
}

由于它不确定具体类型，所以不能将任何元素（Null 除外）放入，即它是只读的，但在很多情况下需要放入对象，因此一种比较常见的方法是使用 类型参数 作为辅助函数

1
2
3
4
5
6
7

public static void swap(List<?> list, int i, int j){
	swapHelper(list, i, j);
}

public static <E> void swapHelper(List<E> list, int i, int j){
	list.set(i, list.get(j));
}

那么 List<?> 和 List<Object> 有什么区别呢？