Java 16包括一项改进，通过JEP 395使语言更加规范，该JEP说：

内层类的静态成员

目前规定，如果一个内层类声明的成员是显性或隐性的静态成员，将是一个编译时错误，除非该成员是一个常量变量。这意味着，例如，一个内类不能声明一个记录类成员，因为嵌套的记录类是隐式静态的。

我们放宽了这个限制，以允许内层类声明显性或隐性的静态成员。特别是，这允许内层类声明一个属于记录类的静态成员。

这听起来像是为了使新特性（记录类）更加通用而做的一个小的必要的恶，实际上它有自己的生命。我们可以用它来模仿C风格的局部静态变量，即局部变量：

• 只初始化一次（而且是懒惰地初始化）
• 在一个方法的多个执行过程中共享

这听起来是一个相当棘手的功能，即只在本地可见的全局变量。但事实上，这是我长期以来一直想要的东西，特别是当我想在不污染类命名空间的情况下缓存正则表达式模式时。

考虑一下这段代码：typescript

 代码解读
复制代码
package p;

import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) {
        check("a");
        check("b");
    }
    
    static Pattern compile(String pattern) {
        System.out.println("compile(" + pattern + ")");
        return Pattern.compile(pattern);
    }
    
    static void check(String string) {
        // Re-compiling the pattern every time: Bad
        // Keeping the pattern local to the method: Good
        System.out.println("check(" + string + "): " 
            + compile("a").matcher(string).find());
    }
}

它打印出来了：scss

 代码解读
复制代码
compile(a)
check(a): true
compile(a)
check(b): false

如果经常编译一个模式，成本会很高，所以我们最好把它缓存起来。我们过去是这样做的：typescript

 代码解读
复制代码
package p;

import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) {
        check("a");
        check("b");
    }
    
    static Pattern compile(String pattern) {
        System.out.println("compile(" + pattern + ")");
        return Pattern.compile(pattern);
    }
    
    // Compiling the pattern only once: Good
    // Placing the pattern in a class namespace: Bad
	static final Pattern P_CHECK = compile("a");
	
    static void check(String string) {
        System.out.println("check(" + string + "): " 
            + P_CHECK.matcher(string).find());
    }
}

现在打印的是一个更理想的输出：scss

 代码解读
复制代码
compile(a)
check(a): true
check(b): false

也就是说，正则表达式模式只被编译一次。但不幸的是，我们不得不污染整个类的命名空间，如果我们有几十个这样的正则表达式，这很快就会变得很麻烦。我们能不能把P_CHECK 变量的范围只扩大到check() 方法？我们现在可以了!typescript

 代码解读
复制代码
package p;

import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) {
        check("a");
        check("b");
    }
    
    static Pattern compile(String pattern) {
        System.out.println("compile(" + pattern + ")");
        return Pattern.compile(pattern);
    }
    
    static void check(String string) {

        // Compiling the pattern only once: Good
        // Keeping the pattern local to the method: Good
        // Capturing scope: Egh...
        var patterns = new Object() { 
            static final Pattern P_CHECK = compile("a");
        };
        
        System.out.println("check(" + string + "): " 
            + patterns.P_CHECK.matcher(string).find());
    }
}

这又一次打印出了所需的、最佳的输出：scss

 代码解读
复制代码
compile(a)
check(a): true
check(b): false

使用var 来使用一个不可取消的类型（其成员我们可以取消引用），再加上将静态成员放在内类中的能力，有效地模拟了局部静态变量，就像在C语言中一样。

由于内层类不太可能逃脱它的作用域，所以它可能捕获作用域的事实并不是什么大的风险，正如之前对双大括号反模式的批评中所说明的那样。你仍然在创建一个额外的类和一个无用的对象，希望逃逸分析能阻止它的分配，所以这并不是一个非常干净的解决方案，但很高兴知道现在可以这样做了。

转载来源：https://juejin.cn/post/7126362346397958158