Java 语法糖，mybatis 的实现原理

}

}

通过反编译后代码我们可以看到，public final class T extends Enum，说明，该类是继承了 Enum 类的，同时 final 关键字告诉我们，这个类也是不能被继承的。

当我们使用 enmu 来定义一个枚举类型的时候，编译器会自动帮我们创建一个 final 类型的类继承 Enum 类，所以枚举类型不能被继承。

[](

)糖块六 、内部类

内部类又称为嵌套类，可以把内部类理解为外部类的一个普通成员。

内部类之所以也是语法糖，是因为它仅仅是一个编译时的概念。

outer.java 里面定义了一个内部类 inner，一旦编译成功，就会生成两个完全不同的.class 文件了，分别是 outer.class 和 outer$inner.class。所以内部类的名字完全可以和它的外部类名字相同。

public class OutterClass {

private String userName;

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public static void main(String[] args) {

}

class InnerClass {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

}

以上代码编译后会生成两个 class 文件：OutterClass$InnerClass.class 、OutterClass.class 。

当我们尝试使用 jad 对 OutterClass.class 文件进行反编译的时候，命令行会打印以下内容：

Parsing OutterClass.class...

Parsing inner class OutterClass$InnerClass.class...

Generating OutterClass.jad

它会把两个文件全部进行反编译，然后一起生成一个 OutterClass.jad 文件。文件内容如下：

public class OutterClass {

class InnerClass {

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

private String name;

final OutterClass this$0;

InnerClass() {

this.this$0 = OutterClass.this;

super();

}

}

public OutterClass() {

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public static void main(String args1[]) {

}

private String userName;

}

[](

)糖块七 、条件编译

—般情况下，程序中的每一行代码都要参加编译。但有时候出于对程序代码优化的考虑，希望只对其中一部分内容进行编译，此时就需要在程序中加上条件，让编译器只对满足条件的代码进行编译，将不满足条件的代码舍弃，这就是条件编译。

如在 C 或 C++中，可以通过预处理语句来实现条件编译。其实在 Java 中也可实现条件编译。我们先来看一段代码：

public class ConditionalCompilation {

public static void main(String[] args) {

final boolean DEBUG = true;

if(DEBUG) {

System.out.println("Hello, DEBUG!");

}

final boolean ONLINE = false;

if(ONLINE){

System.out.println("Hello, ONLINE!");

}

}

}

反编译后代码如下：

public class ConditionalCompilation {

public static void main(String[] args) {

boolean DEBUG = true;

System.out.println("Hello, DEBUG!");

boolean ONLINE = false;

}

首先，我们发现，在反编译后的代码中没有 System.out.println(“Hello, ONLINE!”);，这其实就是条件编译。

当 if(ONLINE)为 false 的时候，编译器就没有对其内的代码进行编译。

所以，Java 语法的条件编译，是通过判断条件为常量的 if 语句实现的。根据 if 判断条件的真假，编译器直接把分支为 false 的代码块消除。通过该方式实现的条件编译，必须在方法体内实现，而无法在正整个 Java 类的结构或者类的属性上进行条件编译。

这与 C/C++的条件编译相比，确实更有局限性。在 Java 语言设计之初并没有引入条件编译的功能，虽有局限，但是总比没有更强。

[](

)糖块八 、断言

在 Java 中，assert 关键字是从 JAVA SE 1.4 引入的，为了避免和老版本的 Java 代码中使用了 assert 关键字导致错误，Java 在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略）。

如果要开启断言检查，则需要用开关-enableassertions 或-ea 来开启。

看一段包含断言的代码：

public class AssertTest {

public static void main(String args[]) {

int a = 1;

int b = 1;

assert a == b;

System.out.println("CSDN-ThinkWon");

assert a != b : "ThinkWon";

System.out.println("博客:https://blog.csdn.net/ThinkWon");

}

}

反编译后代码如下：

public class AssertTest {

static final /* synthetic */ boolean $assertionsDisabled;

public static void main(String[] args) {

boolean a = true;

boolean b = true;

if (!$assertionsDisabled && a != b) {

throw new AssertionError();

}

System.out.println("CSDN-ThinkWon");

if (!$assertionsDisabled && a == b) {

throw new AssertionError((Object)"ThinkWon");

}

System.out.println("\u535a\u5ba2:https://blog.csdn.net/ThinkWon");

}

static {

$assertionsDisabled = !AssertTest.class.desiredAssertionStatus();

}

}

很明显，反编译之后的代码要比我们自己的代码复杂的多。所以，使用了 assert 这个语法糖我们节省了很多代码。

其实断言的底层实现就是 if 语言，如果断言结果为 true，则什么都不做，程序继续执行，如果断言结果为 false，则程序抛出 AssertError 来打断程序的执行。

-enableassertions 会设置 $assertionsDisabled 字段的值。

[](

)糖块九 、数值字面量

在 java 7 中，数值字面量，不管是整数还是浮点数，都允许在数字之间插入任意多个下划线。这些下划线不会对字面量的数值产生影响，目的就是方便阅读。

比如：

public class Test {

public static void main(String[] args) {

int i = 10_000;

System.out.println(i);

}

}

反编译后：

public class Test {

public static void main(String[] args) {

int i = 10000;

System.out.println(i);

}

}

反编译后就是把删除了_。也就是说编译器并不认识在数字字面量中的_，需要在编译阶段把他去掉。

[](

)糖块十 、增强 for 循环

增强 for 循环（for-each）相信大家都不陌生，日常开发经常会用到的，他会比 for 循环要少写很多代码，那么这个语法糖背后是如何实现的呢？

public static void main(String args[]) {

String[] strs = {"CSDN-ThinkWon", "简书-JourWon", "博客:https://blog.csdn.net/ThinkWon"};

for (String s : strs) {

System.out.println(s);

}

System.out.println();

List<String> strList = Arrays.asList(strs);

for (String s : strList) {

System.out.println(s);

}

}

反编译后代码如下：

public static void main(String args[]) {

String[] strs;

String[] arrstring =

【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开：qq.cn.hn/FTf 免费领取

strs = new String[]{"CSDN-ThinkWon", "\u7b80\u4e66-JourWon", "\u535a\u5ba2:https://blog.csdn.net/ThinkWon"};

int n = arrstring.length;

for (int i = 0; i < n; ++i) {

String s = arrstring[i];

System.out.println(s);

}

System.out.println();

List<String> strList = Arrays.asList(strs);

Iterator<String> iterator = strList.iterator();

while (iterator.hasNext()) {

String s = iterator.next();

System.out.println(s);

}

}

代码很简单，for-each 的实现原理其实就是使用了普通的 for 循环和迭代器。

[](

)糖块十一 、try-with-resource 语句

Java 里，对于文件操作 IO 流、数据库连接等开销非常昂贵的资源，用完之后必须及时通过 close 方法将其关闭，否则资源会一直处于打开状态，可能会导致内存泄露等问题。

关闭资源的常用方式就是在 finally 块里释放，即调用 close 方法。比如，我们经常会写这样的代码：

public static void main(String args[]) {

BufferedReader br = null;

try {

String line;

br = new BufferedReader(new FileReader("d:\hello.xml"));

while ((line = br.readLine()) != null) {

System.out.println(line);

}

} catch (IOException e) {

// handle exception

} finally {

try {

if (br != null) {

br.close();

}

} catch (IOException ex) {

// handle exception

}

}

}

从 Java 7 开始，jdk 提供了一种更好的方式关闭资源，使用 try-with-resources 语句，改写一下上面的代码，效果如下：

public static void main(String args[]) {

try (BufferedReader br = new BufferedReader(new FileReader("d:\ hello.xml"))) {

String line;

while ((line = br.readLine()) != null) {

System.out.println(line);

}

} catch (IOException e) {

// handle exception

}

}

看，这简直是一大福音啊，虽然我之前一般使用 IOUtils 去关闭流，并不会使用在 finally 中写很多代码的方式，但是这种新的语法糖看上去好像优雅很多呢。

反编译以上代码，看下他的背后原理：

public static void main(String[] args) {

try {

BufferedReader br = new BufferedReader(new FileReader("d:\ hello.xml"));

Throwable throwable = null;

try {

String line;

while ((line = br.readLine()) != null) {

System.out.println(line);

}

} catch (Throwable line) {

throwable = line;

throw line;

} finally {

if (br != null) {

if (throwable != null) {

try {

br.close();

} catch (Throwable line) {

throwable.addSuppressed(line);

}

} else {

br.close();

}

}

}

} catch (IOException br) {

// empty catch block

}

}

其实背后的原理也很简单，那些我们没有做的关闭资源的操作，编译器都帮我们做了。

所以，再次印证了，语法糖的作用就是方便程序员的使用，但最终还是要转成编译器认识的语言。

[](

)糖块十二、Lambda 表达式

关于 Labmda 表达式，有人可能会有质疑，因为网上有人说他并不是语法糖。其实我想纠正下这个说法。

Labmda 表达式不是匿名内部类的语法糖，但是他也是一个语法糖。实现方式其实是依赖了几个 JVM 底层提供的 Labmda 相关 api。

先来看一个简单的 Labmda 表达式。遍历一个 list：

public static void main(String[] args) {

List<String> strList = new ArrayList<>();

strList.add("CSDN-ThinkWon");

strList.add("简书-JourWon");

strList.add("博客:https://blog.csdn.net/ThinkWon");

strList.forEach(s -> System.out.println(s));

}

为啥说他并不是内部类的语法糖呢，前面讲内部类我们说过，内部类在编译之后会有两个 class 文件，但是，包含 Labmda 表达式的类编译后只有一个文件。

反编译后代码如下:

public static void main(String[] args) {

ArrayList<String> strList = new ArrayList<String>();

strList.add("CSDN-ThinkWon");

strList.add("\u7b80\u4e66-JourWon");

strList.add("\u535a\u5ba2:https://blog.csdn.net/ThinkWon");

strList.forEach((Consumer<String>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$0(java.lang.String ), (Ljava/lang/String;)V)());

}

private static /* synthetic */ void lambda$main$0(String s) {

System.out.println(s);

}

可以看到，在 forEach 方法中，其实是调用了 java.lang.invoke.LambdaMetafactory#metafactory 方法，该方法的第四个参数 implMethod 指定了方法实现。可以看到这里其实是调用了一个 lambda$main$0 方法进行了输出。

再来看一个稍微复杂一点的，先对 List 进行过滤，然后再输出：

public static void main(String[] args) {

List<String> strList = new ArrayList<>();

strList.add("CSDN-ThinkWon");

strList.add("简书-JourWon");

strList.add("博客:https://blog.csdn.net/ThinkWon");

List list = strList.stream().filter(string -> string.contains("CSDN-ThinkWon")).collect(Collectors.toList());

list.forEach(s -> {

System.out.println(s);

});

}

反编译后代码如下：

public static void main(String[] args) {

ArrayList<String> strList = new ArrayList<String>();

strList.add("CSDN-ThinkWon");

strList.add("\u7b80\u4e66-JourWon");

strList.add("\u535a\u5ba2:https://blog.csdn.net/ThinkWon");

List<Object> list = strList.stream().filter((Predicate<String>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)Z, lambda$main$0(java.lang.String ), (Ljava/lang/String;)Z)()).collect(Collectors.toList());

list.forEach((Consumer<Object>)LambdaMetafactory.metafactory(null, null, null, (Ljava/lang/Object;)V, lambda$main$1(java.lang.Object ), (Ljava/lang/Object;)V)());

}

private static /* synthetic */ void lambda$main$1(Object s) {

System.out.println(s);

}

private static /* synthetic */ boolean lambda$main$0(String string) {

return string.contains("CSDN-ThinkWon");

}

两个 Labmda 表达式分别调用了 lambda$main1和lambda1和lambda1和lambdamain$0 两个方法。

所以，Labmda 表达式的实现其实是依赖了一些底层的 api，在编译阶段，编译器会把 Labmda 表达式进行解糖，转换成调用内部 api 的方式。

[](

)可能遇到的坑

[](

)泛型-当泛型遇到重载

public class GenericTypes {

public static void method(List<String> list) {

System.out.println("invoke method(List<String> list)");

}

public static void method(List<Integer> list) {

System.out.println("invoke method(List<Integer> list)");

}

}

上面这段代码，有两个重载的函数，因为他们的参数类型不同，一个是 List，另一个是 List，但是，这段代码是编译通不过的。因为我们前面讲过，参数 List 和 List 编译之后都被擦除了，变成了一样的原生类型 List，擦除动作导致这两个方法的特征签名变得一模一样。

[](

)泛型-当泛型遇到 catch

泛型的类型参数不能用在 Java 异常处理的 catch 语句中。因为异常处理是由 JVM 在运行时刻来进行的。由于类型信息被擦除，JVM 是无法区分两个异常类型 MyException 和 MyException 的

[](

)泛型-当泛型内包含静态变量

public class StaticTest{

public static void main(String[] args) {

GT<Integer> gti = new GT<Integer>();

gti.var = 1;

GT<String> gts = new GT<String>();

gts.var = 2;

System.out.println(gti.var);

}

class GT<T> {

public static int var = 0;

public void nothing(T x) {

}

}

}

这段代码编译都无法通过，因为泛型里面不能引用静态变量。由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，泛型类的所有静态变量是共享的。

[](

)自动装箱与拆箱-对象相等比较

public static void main(String[] args) {

Integer a = 1000;

Integer b = 1000;

Integer c = 100;

Integer d = 100;

System.out.println("a == b is " + (a == b));

System.out.println(("c == d is " + (c == d)));

}

输出结果：