Java语言简介

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

• JavaSE（J2SE）（Java 2 Platform Standard Edition，Java平台标准版），更多的时候用于PC客户端，用的不多。
• JavaEE（J2EE）（Java 2 Platform,Enterprise Edition，Java平台企业版)，用的很多，主要用于企业级开发（Web、后台等等）。
• JavaME（J2ME）（Java 2 Platform Micro Edition，Java平台微型版)，更多的时候用于手机等微型设备端，Nokia时代有人用，现在已经基本没人用了。

跨平台特性

稍微有一些计算机基础知识的同学都知道，不同硬件，它们的区别是很大的，不同的操作系统，区别也很大，毕竟，操作系统是直接工作在硬件之上的。操作系统已经为我们提供了比较一致的操作计算机硬件的接口，但是不同的操作系统因为当初的发明者、后来的开发者，以及不同公司的各种因素等等，导致这些操作系统本身之间的差异就很大，比如要保存一个文件到计算机中，比如要发送一个网络请求，不同的操作系统，差别就非常大。而且在这些操作系统上可以执行的程序的格式本身也不一样。

在计算机软件开发刚刚兴起的最初那些时代，人们想让计算机做一件事情，通常要针对不同的操作系统分别实现一套程序，然后再对这些程序的运行工作情况进行测试验证，才能保证它的工作是符合预期的。这种方式下，工作量比较大、软件开发的成本、效率都不是很理想。所以，后来人们发明了C语言、C++语言等高级语言，这些高级语言基本上屏蔽了不同操作系统之间的这些差异，比如读取一个文件，在C语言中，无论是什么操作系统，都可以通过fread函数来做到。但是，不同的操作系统上的可以执行的程序的格式也是不一样的，所以，虽然写了一份可以在多个操作系统上运行的软件源代码，但是想要让程序可以运行，还需要一个编译的过程中，所谓编译，简单的理解，就是将人类能读懂的程序源代码翻译成机器可以识别的机器码，然后再以相应的操作系统上预先定义好的格式组织起来，让这些操作系统碰到它们的时候可以直接执行。

由上述情况我们了解到，针对C、C++语言，我们可以编写一份能够在各个平台上都可以执行的源代码，然后针对不同的操作系统分别编译出对应的可执行程序，就能实现跨平台，但是这个过程还是比较烦琐的，不同的操作系统上的环境千差万别，要编译出一份正确的没有问题的程序，也是很麻烦的。

所以，Java的开发者，新创造了一种模式，他们开发了一套软件，这套软件作为Java程序和各操作系统之间的中间层而存在，我们姑且称之为执行引擎，这个名叫执行引擎的中间层可以屏蔽不同的操作系统之间的差异，我们这些软件开发人员，只要将源代码写好，然后编译成执行引擎能识别的格式（现在我们称其为字节码）就行了。当然，执行程序的时候，也不是交给操作系统去执行，而是交给这个执行引擎，执行引擎再去完成字节码程序的执行过程。这样，对于我们普通开发者来说，就不必考虑不同的操作系统之间的巨大差异了，这就是Java语言的Write once, run anywhere的理念，即：一次编写，到处运行。

当然了，事实上这仅仅是一个美好的愿望，世上没有完完美的东西，Java语言的这种做法，固然为我们解决了不同操作系统之间的差异问题，但是因为有这个执行引擎的再处理，代码不会直接运行在硬件上，而是有中间层的翻译转换这个过程，所以性能会有损耗，好在现在的计算机运行速度都很快，所以大多数情况下是没问题的。当然也正是因为这个原因，在一些性能要求非常高的场景，人们还是仍然在用C语言和C++语言开发程序，然后编译成可以直接执行的格式，虽然麻烦了点，但是性能有保证啊。

看下面这张图，就更好理解了：

JDK和JRE

JDK是一套软件的总称，指的就是Java语言现在的主要开发商美国的Oracle公司开发的整套Java语言开发工具包（Java Development Kit），有了这个，Java语言就不再是非常简单的一门语言了，它提供了非常丰富的、高性能的、扩展很极强的各种工具包，我们可以使用这些工具包直接开发出自己想要的软件产品出来。

提到JDK，我们就需要顺便说一下JVM，JVM不是一个软件，而是一套基于Java语言做软件开发的规范，在这一套规范之下，各厂商分别实现了一套自己的Java语言开发工具包（还是可以继续简称为JDK了），比如IBM有自己的JDK、Amazon也有自己的JDK、Oracle作为官方正统当然也有自己的JDK。只不过我们平常见的最多的、用的最多的都是OracleJDK，所以就变成提到JDK，就指的是Oracle的JDK了。JDK最早是SUN公司开发的，后来被Oracle公司收购，所以就变成OracleJDK了，市面上常见的JDK有两种：OpenJDK和GraalvmJDK，据业内大神验证，OpenJDK的性能比OracleJDK的性能高20%，而GraalvmJDK的性能又比OpenJDK的性能高20%。当然了，这三套JDK是完全兼容的，你可以随意通用。

OpenJDK和OracleJDK虽然同宗同源，技术特性也很相近，但是它们还有一些区别的，OpenJDK采用GPL v2协议放出，而Oracle JDK则采用JRL放出，此外，OpenJDK只包含基本的JDK实现，而OracleJDK却还包含了其他一些辅助工具（Oracle官方还号称做了许多优化），所以，有人说OpenJDK is an open source version of sun JDK. Oracle JDK is Sun's official JDK.。在2018.9之后，Oracle JDK正式商用（开发不收费，但是运行线上业务收费，所以，开发软件时，使用这两个JDK都可以，但是线上运行时应该使用OpenJDK。尤其有一点要注意，不要去Oracle官网下载他们提供的JDK11，除非你真的弄清楚了它的License并且确定知道自己要怎么做。推荐大家去这里下载：http://jdk.java.net/archive/

JVM就是Java虚拟机（Java Virtual Machine），Java这个编程语言有点特殊，开发出来的程序，编译完之后不是二进制的机器码可以直接让硬件解析执行，而是字节码，这种东西机器不能直接执行，需要在执行的时候再“翻译”一遍。做这个“翻译”的工作的，就是JVM。JVM屏蔽了各操作系统之间的差异，使得上层的Java代码编译出来的字节码可以跨平台运行，实现所谓的“一次编写，到处运行”（Write once, run anywhere）。

说完了JDK，再来说JRE。话说JDK的功能是非常强大的，平时我们开发软件需要用到的东西基本上都有了，但是它有一个问题：当我把软件开发完了之后，运行的时候，我并不需要这么多东西，只需要一个最小支持层就可以了，这个时候，就只需要JRE了，JRE只包含支撑开发好的Java程序运行的组件，不包含开发相关的一些东西。

所以JRE是JDK的一个子集，JVM是JRE的一个子集。

顺便提一下Java语言的版本史，Java最主要的版本是JDK6和JDK8，这是目前市面上见的最多的，JDK6是很多老项目的JDK，如果你去了一家历史悠久的大公司，你会发现他们很多十几年前开发的项目都是基于JDK6的，新兴公司，大都使用JDK8。当然了，截止本文发布，JDK17都已经发布了。这期间还有JDK11、JDK15是LTS版本（长期支持版本）。

开发环境配置

在本章节中我们将为大家介绍如何搭建Java开发环境，不同的操作系统，搭建环境略有不同：

Windows 上安装开发环境

下载JDK 首先我们需要下载 java 开发工具包 JDK，下载地址：https://www.oracle.com/java/technologies/downloads/ ，在下载页面中根据自己的系统选择对应的版本，本文以 Window 64位系统为例：

我们推荐下载zip格式的绿色包，许多网站都建议选择exe格式的安装包运行安装，这里之所以推荐zip格式的绿色包，是因为对于开发经验丰富的人来说，许多时候，要在多个JDK版本之间做一些研究和学习，这就很有必要了。

下载解压之后（当然你也可以下载exe格式的进行安装），要配置环境变量，具体如下：

• 变量名：JAVA_HOME，变量值：C:\Program Files (x86)\Java\jdk1.8.0_91
• 变量名：CLASSPATH，变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
• 变量名：Path，变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

注意 ：JAVA_HOME变量的值，要根据你具体安装或解压到哪里了，换成你电脑中的路径，CLASSPATH变量的值是固定的，但是记得它的值最开头有个”.“，不能忽略。Windows上Path环境变量是以英文分号分割的，配置的时候注意和别的已有环境变量以英文分号分开，别连在一起了。

Linux 上安装开发环境

Linux、Mac OS X上其实原理和Windows上差不太多，要注意的是Linux和Mac OS X上Oracle也提供了安装版的JDK，只不过一般没人这么用，都是下载压缩包解压，然后这样配置：

• 变量名：JAVA_HOME，变量值：/opt/jdk8
• 变量名：CLASSPATH，变量值：.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
• 变量名：PATH，变量值：$JAVA_HOME/bin:$JAVA_HOME/jre/bin
  

注意 ：JAVA_HOME变量的值，要根据你具体安装或解压到哪里了，换成你电脑中的路径，CLASSPATH变量的值是固定的，但是记得它的值最开头有个”.“，不能忽略。Linux、Mac OS X上PATH环境变量是以英文冒号分割的，配置的时候注意和别的已有环境变量以英文冒号分开，别连在一起了。

安装Eclipse进行Java开发

这是免费开源的IDE（集成开发环境）。

早在2000年前后，当时大家使用Java语言开发大型软件时，用的是位于美国的著名大公司IBM开发的一款名叫Visual Age for Java的IDE开发工具，2001年，IBM又在此基础之上，开发了全新的IDE开发工具，起名叫Eclipse，当时IBM是Java阵营的头部企业（当时Java还属于美国的Sun公司而不是现在的Oracle），微软则正在力推C#以及Java的变种J++，IBM为了在与微软的竞争中胜出，将Eclipse开源，并联合Borland、Red Hat、suse等一些一流厂商，成立了Eclipse基金会，当然了，这个过程不是一帆风顺的，期间经历了很多事情才得以成功，Eclipse基金会成立的时候已经2004年了，但是无论如何，这是一次成功的商业行动，Eclipse作为一家非营业利性质的中立机构，拥有完整的章程、协议、行为准则等。他们将Eclipse工具深化发展，由最初的一个IDE工具最终发展成为了一个开放性的、具备极强的包容性的综合性的开发平台。当然了，在此期间，Java语言的东家也已经由Sun公司转为了Oracle公司，Eclipse又与Oracle就Java语言相关的协议等内容达成了一系列共识，最终成为了现在业界独一无二的优化、强大的软件开发平台。所以，Eclipse不仅仅能用来开发Java程序，还能开发其他编程语言的程序，而且完全胜任大型、超大型的软件系统的开发工作。

安装IDEA进行Java开发

这是一款商业化的、功能非常强大的IDE（集成开发环境），非常好用。

关键字

说Java基础语法之前，我们先说一下关键字。所谓关键字，就是Java语言本身在使用这个单词，然后你在使用Java语言编写代码开发软件的时候，就不能使用这些名字了，因为这些名称被用于特殊用途了。不必记忆，放在这里备忘备查就好了。

Java语言中有以下关键字：

数据类型

基础数据类型：

Java的每一种基本数据类型，都应对一种包装类型，如我们最常见的基本类型int，它对应的包装类型是Integer，那么这个包装类型是用来做什么的呢？事实上，这个包装类型，是专门用来处理“面向对象编程”的。不好理解？不要紧，我们换个说法：现在要保存一个整数列表，我们需要使用List<Integer>而不能是List<int>，为什么？因为List中的内容必须是一个个的对象，而不是数字，是的，你没看错，如果你在Java中写了一个int类型的数字10，它不是个对象，所以它不能放到List中去。而Integer类型的数字10就能放到List中去，因为它是个对象。最后再来究极一问：为什么int类型的一个数字不是对象而Integer类型的一个数字就是对象了呢？答案是：Java就是这么设计的，为什么这么设计呢？为了性能，int类型的数据，都是在栈上甚至是寄存器上运行，很快，而Integer类型的对象，必须在堆上，慢啊。既想要性能，又想要面向对象，所以，就这么人格分裂咯。

变量的定义和使用

这个太简单了，几乎没什么可说的，看代码：

int a = 10;
double b = 3.14;
String s = "name";

只有一点需要注意：基础类型和包装类型是不一样的，前面已经讲过了。另外，变量定义的时候，名称不要胡起，比如你生个孩子，起个名字叫混账，这怎么能行呢😂？起名字要“正常”一点，比如学生，就叫student，比如评分，就叫score。见名知义，是最好的😀。

我们还可以定义一些稍微复杂一点的变量：

int[] numbers = new int[]{1, 2, 3};
List<String> charactors = new ArrayList<>();
Map<String, String> students = new HashMap<>();

第一个是定义了一个数组，第二个是定义了一个列表，第三个是定义了一个Map（键-值映射）。这些都是JDK为我们提供的能力，可以很方便的保存各种复杂的业务数据。需要注意的是：像列表、Map可以在定义的时候保存数据，也可以定义好了之后再保存数据，这些我们以后会接触到。

知道了变量的定义，就要掌握运算符。请看后续章节，让我们继续学习运算符。

运算符

算术运算符

算术运算符的结果类型不变，原来是什么类型，结果仍然是什么类型：

这里会有一些隐式的类型转换，原则：小类型向大类型自动转型（当然也可以手动强制转换）。

关系运符符

关系运算符的计算结果是一个boolean型的结果：

= | 检查左侧是否大于等于右侧，大于或等于得true，其他情况得false | a >= b
<= | 检查左侧是否小于等于右侧，小于或等于得true，其他情况得false | a <= b

逻辑运算符

逻辑运算符的计算结果是一个boolean类型的结果：

运算符优先级

运算符优先级原则：

• 算术运算符优先级高于关系运算符
• 关系运算符优先级高于逻辑运算符
• 可以使用括号手动改变运算顺序，这很有用，既便于理解，又能很好的控制计算顺序

Java运算符优先级

这张表其实不用记忆，放在这里只是备查

在上述的Java编程语言的运算符优先级表格中，越靠近表的顶部，其优先级就越高。在遇到相对较低优先级的运算符之前，对具有较高优先级的运算符进行求值。同一行的运算符具有相等的优先级。当具有同等优先级的运算符出现在同一表达式中时，必须首先控制一个规则。除赋值运算符外，所有二元运算符从左到右进行求值（左结合性）；赋值运算符从右至左进行运算（即：将右边的值赋给左边）。

流程控制

分支判断

这个也很简单，示例代码：

int score = 100;
if (a > 60) {
    System.out.println("万岁")
} else {
    System.out.println("受罪");
}

是不是很简单？这段代码中的System.out.println是JDK提供的一个类和方法，用于在屏幕上输出内容，眼下你会用就行了，细节以后再学习研究。

后面的else不是必须的，换句话说，我可以实现一个需求：某个条件符合时，做某个，不符合时，什么也不做。如下所示：

int score = 100;
if (a > 60) {
    System.out.println("万岁")
}

但是要注意：以上述代码为例，万一有人弄进来了一个200分呢？或者这个时候有个表示年龄的变量，它的值是已经是500了呢？我们知道人是不可能活500年的（我真的还想再活500年，那只会在歌曲中出现哦~），这个时候，其实它就有个BUG，代码在某些时候，运行的结果就是错的，所以，要改：

int score = 100;
if (a > 100) {
    System.out.println("这是什么鬼，我不认识");
} else if (a > 60) {
    System.out.println("万岁");
} else {
    System.out.println("受罪");
}

这个代码逻辑就没问题了，同样的，处理人的年龄的时候，也应该是这样的：

int age = 100;
if (a > 120) {
    System.out.println("史无前例的高寿，有福啊！");
} else if (a > 100) {
    System.out.println("高寿，有福啊！");
} else if (a > 80) {
    System.out.println("老寿星，您好！");
} else if (a > 60) {
    System.out.println("老爷爷好！");
} else if (a > 40) {
    System.out.println("叔叔好！")
} else if (a > 20) {
    System.out.println("哥们好！")
} else if (a > 3) {
    System.out.println("小朋友你好！")
} else {
    System.out.println("去吃奶吧。");
}

对于固定的、又有很多个值的情况，写那么多的if…else明显有点难受，Java为我们提供了switch，也很方便，示例：

char ch = 'a';
switch (ch) {
    case 'a':
        System.out.println(1);
        break;
    case 'b':
        System.out.println(2);
        break;
    case 'c':
        System.out.println(3);
        break;
    default:
        System.out.println(0);
        break;
}

是不是简洁易读多了？需要注意的是，break语句是必须的，如果没有，会导致所谓的switch Fall-through，当然，特殊情况下也是有用的：

int a = 1;
switch (a) {
    case 1:
    case 2:
    case 3:
        System.out.println("top3");
    case 4:
    case 5:
        System.out.println("top5");
        break;
    default:
        System.out.println("not");
}

这段代码的逻辑有点特殊，我帮你要梳理一下：如果a的值是1、2、3，那么就是top3，如果a的值是1、2、3、4、5，那就是top5，如果a的值是4、5，那么它是top5但不是top3，这些情况都不是，那就not。

如果switch…case语句中，case后面的内容是字符串，只能在JDK7及以上使用，更老的项目上是不支持的：

String s = "a";
switch (ch) {
    case "a":
        System.out.println("A");
        break;
    case "b":
        System.out.println("B");
        break;
    case "c":
        System.out.println("C");
        break;
    default:
        System.out.println("0");
        break;
}

fall through的字面意义是落空、告吹、破灭。但是在这里明显感觉有点词不达义。大家将就着理解吧，目前网上没找到权威的解释，都处于一种“代码就是这样的，执行时的行为是那样的，你自己领悟吧”的状态中。

循环

Java中主要有三种循环： - for循环 - while循环 - do…while循环

for循环

Java中的for循环通常用于知道循环次数的情况，如：

for (int i = 0; i < 10; i ++) {
    System.out.println(i);
}

逻辑很简单：将0到9打印出来。

for循环还有另外一种用法：遍历数据，这种用法叫增强for循环，如下所示：

int[] numbers = new int[]{1, 2, 3, 4, 5};
for (int number ： numbers) {
    System.out.println(number);
}

这是遍历numbers这个数组，数组内容变化之后，for循环不必修改，仍然能将数组的所有内容都打印出来，很方便。但是这里要注意：numbers不能是null，否则会抛出NullPointException，所以循环之前要判断一下。具体什么是异常，我们以后会再学到。 👉Tips：这种循环又称为增强for循环，或foreach循环，它是JDK5中才出现的。

while循环

语法：

while( 逻辑表达式 ) {
  //循环内容
}

只要逻辑表达式的值为true，就会一直循环执行下去，通常用于根据唯一条件进行循环，如：

int r = 0;
while (r >= 100) {
    r = getDownloadPercent();
    System.out.printf("Downloading %d", r)
}

这段代码的逻辑很简单：getDownloadPercent是一个模拟方法，它获得文件下载的进度，当下载进度是100的时候，就退出循环了，循环条件也可以写成r == 100，但是在某些情况下，有可能出现超出100的时候，那就死循环了，所以为了确保万无一失，我们写成r >= 100，这就是代码的健壮性了。

do…while循环

do…while循环通常用于不知道循环次数，只能在某种情况下结束，这种情况要注意，一个不小心就死循环了，所以写这种代码的时候，逻辑要理清楚。另外，do…while还有一个好处，它不执行判断条件，直接开始执行这个do…while逻辑块中的代码，执行完了再判断是否进行下一次循环。示例：

// 用户手机号列表
List<String> mobileList = null;
int page = 1, pageSize = 10;
do {
    mobileList = queryUserMobilesByPage(page, pageSize);
    page++;
} while (mobileList != null && !mobileList.isEmpty());

这是一个非常典型的示例应用：先定义一个保存手机号的列表，然后定义页码和页大小，然后按指定的页大小逐页查询所有手机号。如果找不到了，就结束循环。

类和实例

关于类

什么是类？类就是对同一种东西的抽象，抽象层次不同，形成的结果差异也很大。比如：人，这个抽象级别就非常高，可以概括我们所有人，比如学生，它的抽象级别就低多了，限定了年龄、职业等信息，再比如：男学生，就在学生的基础上更趋向于具体：在学生的基础上，限定了性别。所以，我们可以通俗的理解：抽象级别越高，能概括的范围越广，抽象级别越低，越趋近于具体的某个事物。接续前面的描述：某某学校的、学号为某某某、年龄为某岁的男学生。这就到了这个具体的学生了，它就不是抽象，而是具体。

到此，相信大家都已经理解了什么是类了，类就是对同一种东西的抽象。

在Java中，定义一个类非常简单：

class People {
}

这是个类，但是它是空的，里面什么都没有。

针对类，我们还可以添加一些字段用于表述它们拥有哪些特性，再添加一些方法用于表述它们能做些什么：

class People {
    String name;
    int age;
    String getName() {
        return name;
    }
    void sayHello() {
        System.out.println("你好");
    }
}

在这个类中，它拥有两个字段：name和age，用于表述这个类具有姓名和年龄，此外它还拥有两个方法：getName、sayHello，在Java中，定义变量的时候，首字母小写，其他单词的首字母大写，定义类的时候，每个字母都大写，这叫驼峰命名法。顺便来几个示例： - 变量名：name、age、address、mobile - 类名：User、Student、PublishQueue、MyStack、HttpClient > 通常情况下，一个java代码文件中放一个类，然后让该文件名称和类名称完全一致，当然也可以放多个，但是这涉及到代码包和访问权限的问题，我们后面再说。

对于getName这种获得这个类的成员，Java中有一个约定俗成的做法：方法名称是由字段名演化而来的，具体的演化规则是，字段名称首字母大家，然后前面加上get，其余保持不变，这是获取字段属性，所以有人称之为获取器，相信聪明如你，肯定想到了，既然能获得一个类的字段，那么能不能设置一个类的字段呢？答案当然是可以的，如下所示：

class People {
    String name;
    int age;
    String getName() {
        return this.name;
    }
    void setName(String name) {
        this.name = name;
    }
    int getAge() {
        return age;
    }
    void setAge(int age) {
        this.age = age;
    }
}

看，其实很简单吧，getter是获取器，又称访问器，用于获得字段的值，setter是设置器，用于修改字段的值。

此外，在定义类的时候，我们还可以在类的内部再定义一个类（也就是嵌套），这个叫内部类：

class Student {
    String name;
    int age;

    class Address {
        String province;
        String city;
        String county;
    }
}

理论上我们还可以在方法中定义类，但是基本上没人这么用，我们就忽略吧。

关于类的定义，相信你已经看到上面的一些代码中，方法中有个this，它代表该类的一个实例，那么什么是实例？这个this又是哪个实例呢？

关于实例

实例，就是某个具体的事物，比如前一节中所描述的某某学校的、学号为某某某、年龄为某岁的男学生，这就是很具体的一个学生，而不是很简单很抽象地说人，因为这样太笼统了，很难在许多业务场景中直接使用。

所以，实例，是对类的具体定义。那么，当我们定义了类之后，我们就能定义实例了。定义类的时候，我们要明确它的一些具体属性，比如学生，就是一个类，它的所在学校、学号、年龄等属性，任何学生都有这些属性，但是具体到各个学生，他们的很多信息是不一样的，所以，类型是共性，实例是个案。

在Java中，定义一个类的实例也很简单：

People p = new People();

我们接着往下看：

People p1 = new People();
System.out.println(p1.getName());
People p2 = new People();
System.out.println(p2.getAge());

这里，我们针对类People，创建了两个实例：p1和p2，那么，当执行p1.getName()方法时，this就是p1，当执行p2.getAge()方法时，this就是p2。现在理解了吧。

这里要强调一个事情：类有字段，但没有字段值，只有实例才有字段值。为什么是这样的？你想想：人的年龄是20岁，这话有毛病没有？你突然听到这一句话，不蒙么？但是我要是说：张三这个学生年龄是20岁。这话就一点问题都没有。类是一个抽象的东西，它不拥有具体的字段值，只有具体的某个事物，才拥有具体的某些特性，所以，再强调一遍：通常情况下，类只有字段，实例才有字段值。

但是也有例外，某些时候，某个类的所有实例，都拥有一个相同的属性，在它的所有实例中写一遍，似乎也比较麻烦，而且也不太合理，那么此时我们可以把这个属性放到类中，变成类的一个字段，这样这个类的所有实例就可以直接使用了，如下所示：

class People {
    String name;
    int age;
    static String color = "黄色";
}

所有人的皮肤都是黄色的，就统一放到类中去（用static关键字标表这种用法），那么这个类的所有实例都可以使用了，省的到处写一遍，唔…没毛病。

People p = new People();
System.out.println(p.color);

当一个类中有static型的字段时，我们除了通过实例访问它，还可以通过类名直接访问它，如下所示：

System.out.println(People.color);

这个很好理解，color是People这个类的，不是某个实例的，所以在没有实例的情况下，我们可以直接使用它。

还有，在一个类中再定义内部类的时候，也可以指定该内部类是否为static，同样的道理：如果该内部类是static的，那么我们可以直接在外部类上使用，如果该内部类不是static的，当然就不能在外部类上直接使用了，这个时候它是属于外部类的实例的，有了外部类的实例，才能通过实例使用该内部类。

class Student {
    String name;
    int age;

    static class Address {
        String province;
        String city;
        String county;
    }
}

类的继承机制与接口

前面我们已经描述清楚了什么是类，但是我们同时也发现，学生这个类型，它有一些东西，其实是和人这种类是通用的，所以，我们可以进一步进行归纳整理，先定义人这种类型，再定义学生这种类型，然后让学生这种类型继承人这种类型，那么就感觉简单明了多了。类似地，我们用一张图表示这样一种抽象逻辑关系：

那么，接口又是什么呢？接口其实是对类的行为的抽象定义，比如人的吃饭行为、动物的奔跑行为，定义了之后，就可以让某个类拥有这些行为，当一个类拥有一个接口的所有行为时，我们称该类实现了该接口。同时，这些行为还可以给其他类使用，这叫复用，能够让同一种东西（比如移动这个行为）在多个地方使用，这对于简化软件开发具有重要意义，在以后的具体的开发中，我们会接触到更多这方面的信息。

了解了这些信息，那么具体写代码的时候怎么做呢？其实很简单的，往下看。

在Java中，让某个类继承另外一个类的写法是这样的，先定义父类：

class People {
    String name;
    int age;
}

再定义学生子类，并让该子类继承父类：

class Student extends People {
    String studentId;
}

extends是关键字，表明子类Student继承了People类，而且子类拥有父类的name和age两个属性，再加上自己本身拥有的studentId属性，它就拥有三个属性了。

我们还可以再定义一个老师类：

class Teacher extends People {
    List<String> lessonList;
}

子类Teacher和Student类一样，也拥有三个属性：name、age、lessonList。

需要注意的是：在Java中，只能实现单继承，不支持多继承，也就是说：b可以继承a，然后c也可以继承a，此时不能再定义一个d同时继承b和c，这是不可以的，有的同学可能熟悉C++，知道能这么定义，Java不可以。

在Java中，定义一个接口也很简单：

interface Moveable {
    double distance();
}

现在，定义一个类，让这个类实现这个接口：

class Dog implements Moveable {
    @Override
    double distance() {
        System.out.println("小狗在奔跑");
        return 10.123;
    }
}

这个定义表明：我们有一个描述移动的接口，同时定义了一个狗类，狗能移动，于是它实现了Moveable这个接口（通过implements关键字），代码中的@Override就是用于表明这个distance方法是来自接口的，它是可选的，可以不写，但是为了便于代码一目了然易于理解，我们还是写上比较好。

我们可以通过上述例子看到，类是包含各种字段（代表数据）和方法（代表行为）的，接口仅仅是声明方法（行为）的。可是有的时候，我们还有一个需求：我定义一个类，规定一些行为，但是又有部分行为只声明不实现，让别人继承它去自己做，兼具灵活性和便捷性。这个时候，就需要通过abstract声明抽象类，如下所示：

abstract class AbstractRequest {
    String url;
    String param;
    abstract public String doRequest();
    public String buildParam(Map<String, String> param) {
        for (String key : param.keySet()) {
            this.param += String.format("%s=%s?", key, map.get(key));
        }
    }
}

在上述代码中，我们声明了一个发送网络请求的类，同时我们写了一个buildParam方法，将一个Map转化成为字符串，无论是GET还是POST还是其他请求，URL上需要参数的时候，我们都可以调用buildParam方法，但是GET、POST等请求的具体执行逻辑是不一样的，而且我们也不知道使用我们这个类的人他什么时候用什么请求，所以这个时候，我们声明了一个抽象方法doRequest()，它只有声明没有实现，目的就是让使用这个类的人去继承这个类，然后实现这个方法。你可以简单地理解：我声明了一个模板，基础的东西我都搞好了，具体怎么发请求，你自己去弄，弄好了就可以直接用了。注意： 如果一个类中有至少一个方法被声明为抽象方法了，那么该类就必须是抽象类。

一个大型、超大型的软件，其中的类继承关系一般是比较复杂的，这也是通常情况下这样的软件会有很多个人一起开发，最后进行系统集成的原因所在，我们再看看JDK中最常用的ArrayList这个类的继承关系如下图所示：

带I标识的是接口，带双竖线的C的是抽象类，带C标识的是类

static块

之所以将这个static块单列一节讲，是因为它比较特殊，分两方面说。

第一：我们前面已经说了，如果一个内部类是static的，那么外部类可以直接使用它，因为它和外部类是绑定在一起的，如果一个内部类不是static的，那么外部类不能直接使用它，要么将内部类实例化之后使用它的实例，要么外部类实例化之后，通过外部类的实例访问内部类。

第二：一个类的static块，是在JVM进程启动的时候执行的，而不是实例定义的时候（也就是new这个类的实例的时候）执行的，有下面的示例代码：

public class Student {
    static {
        System.out.println("Student static块");
    }
    static class Address {
        static {
            System.out.println("Student.Address static块");
        }
    }

    public static void main(String[] args) {
        System.out.println("Student.main 方法 1");
        System.out.println(new Student.Address());
        System.out.println("Student.main 方法 2");
    }
}

并且，内部类的static静态块只会在它被实例化的时候执行。

如果你有Java基础了，可以运行上述代码看看，如果没有，也没关系，我们后面学了怎么运行代码之后，再回过头来运行它也是可以的。

代码包和访问权限

掌握了上面这些知识之后，我们就可以写很多个类、实例、变量等等，再定义一些数据结构，用于表示我们的业务系统中的一些东西了，进而把需求实现出来，做出一套软件系统，但是，这里面有一个非常常见的问题：我定义的某个东西，想让所有人都能访问，或者，我定义的某个东西，我只准备自己用，不想让其他人使用。这个要怎么做到呢？这就涉及到代码包和访问权限了。

事实上，代码包不仅仅是用来控制权限的，它还是用来组织代码的，当一个软件中代码很多的时候，我们肯定要分门别类把它们组织好，否则乱成一团，最后就太复杂了，就搞不定了。

代码包

代码包，其实就是把担负相同职能的代码放在一起，比如做数据计算的多个类放在一个文件夹中，做网络请求的多个类放在一个文件夹中。于是就有类似于下面这样的结构：

.
├── src
│   ├── math
│   ├── network
│   ├── file

是不是看上去简洁明了了许多？但是，即使有这样的管理思路，仍然要解决每个人都单独搞一套的问题，只有大家都统一使用一致的代码管理策略，才能防止各个地方的代码千差万别，因为代码是为了解决大家需求上的实际问题的，所以这种千差万别只会让软件开发成本上升，不利于软件产品快速交付。所以，我们有一套统一的约定，所有人都按这个方式组织自己的代码，如下所示：

.
├── src
│   ├── main
│   │   ├── java
│   │   ├── ├── domain
│   │   ├── resources
│   ├── test
│   │   ├── java
│   │   ├── ├── domain
│   │   ├── resources
│   target

针对上述结构，我们很有必要逐项解释一下： - . 指的是项目根目录，这个很好理解，你有可能会开发多个软件，每个软件的代码都放在自己的某个目录中，这个目录就是该软件代码的项目根目录 - src 指的是源代码目录，这个目录中放的都是源代码 - main 这里放的是软件产品的代码，以及软件运行时所需的资源文件和配置文件 - java 这里放的是软件产品的真正代码，一套软件包含很多东西，真正的软件代码放在这里 - resources 这里放的是软件产品的资源文件和配置文件，一个软件要运行起来，需要很多资源和配置（比如数据库的IP、端口、账号和密码等），并且有可能不同的环境不一样（比如测试环境和生产环境以及演示环境的账号密码是不一样的），它们放在这里 - src 这里放的是软件产品的测试代码、以及运行测试代码所需的资源文件和配置文件 - java 这里放的是软件产品的测试代码，测试代码是用于测试验证软件的真正代码是否能够正常、正确地运行的，由于每个开发者对需求的理解不同、开发人员的水平不同，或者团队之间协作存在问题，都会导致软件的代码可能会出现问题，这个时候我们就需要编写测试代码，对软件真正的代码的运行情况进行测试验证，确保它们的运行行为、运行结果是符合预期的，只有这样的产品才是有用的产品，才能交付给客户 - resources 这里放的是运行软件产品的测试代码时所需的资源文件和配置文件，一个软件的测试代码要运行起来，需要很多资源和配置（比如数据库的IP、端口、账号和密码等），并且有可能不同的环境不一样（比如测试环境和生产环境以及演示环境的账号密码是不一样的），可以将它们放在这里 - target 这里放的是编译之后的字节码文件，以及将很多字节码文件、资源等各类支持、配置文件一起打包生成的jar文件的war文件 - domain 在上述代码包结构中，main/java和test/java下都有一个domain，它其实是个域名的含义，但通常会倒着写。什么意思呢？比如你们公司的域名或者你正在开发的软件产品使用的域名是a.com，那么这个domain就是com.a，此时真正的软件代码自然是放在目录src/main/java/com/a中的，同样的，测试代码也是放在目录src/test/java/com/a中的。

当我们将自己的代码文件按上述结构放到相应的目录中的时候，我们就完成了对代码文件的组织管理的第一步，还有最重要的第二步，就是在代码文件中声明该代码文件的包名，例如，我们在src/main/java/com/a目录下创建了一个Hello.java文件，那么就要在这个代码文件的开头这样写：package com.a;，这表示这个Hello.java中的类都是包com.a下的。

访问权限

回到我们之前曾经提到过的一个问题：当我将自己的代码分门别类的组织好了之后，有一个需求就出现了：某些代码我不想让别人访问，某些代码我想让别人访问，某些代码我想让相同代码包中的人访问而其他人不能访问，这就要使用访问权限来解决了，Java中提供了三个关键字public、private、protected，用于解决这个问题。具体约定如下：

我们对上面这个解释一下： - public关键字用于修饰一个类、类中的内部类、类中的字段，此时任何人都能访问它 - protected关键字用于修饰类中的字段成员，以及类中的内部类，此时只有本包中的其他类和当前类的子类能访问它 - private关键字用于修饰类中的字段成员、以及类中的内部类，此时只有本包可以访问它 - default并不是说default关键字，而是指当我们写了一个类、字段、内部类时什么都没有加的时候（既没有public、也没有protected、也没有private）的默认值，此时只有该类能访问它 - 总体上，在一个类内部，无论用什么修饰，都能访问 - 最后再加一个约定：一个后缀为.java的源代码文件中，用public修饰的类，有且只能有一个

下面写几个例子看一看：

一个单独的公开类文件：

// Hello.java
public class Hello {
}

一个单独的公开类文件，内部有字段和内部类：

// Hello.java
public class Hello {
    public String name = "hello";
    private int order;
    protected List<String> elements;

    public class Greet {
    }
}

在一个代码包com.example.io中，有多个类：

 // 文件：src/main/java/com/example/io/File.java
 package com.example.io;

 public class File {
     private String name;
     private String size;
 }

// 文件：src/main/java/com/example/io/FileOperator.java
package com.example.io;

public class FileOperator {
     private int result;
     public create(File file) {
         // 创建文件的实现代码
     }
     public delete(File file) {
         // 删除文件的实现代码
     }
 }

最后再说一个业界通行的做法：一般情况下类中定义给实例用的字段成员，通常都是private的，顶多是proctected，不会是public，只有放在类上直接使用的字段，才会是public，然后对实例上要用的各字段，添加getter和setter方法。这么做的好处是：如果这里的代码逻辑有变动，调用这段代码的人可以不必修改。所以，我们上述的各测试代码，都省略了getter和setter方法。 > 事实上，当前阶段，许多人都发现了这个问题：假设一个类中有20个字段，那么它就有40个方法，代码很长很冗余，可是又不能没有，很麻烦，所以就有业界的大神搞了一个叫lombok的东西来简化操作，这个我们以后会涉及，今天了解一下就可以了。

注意： 使用package关键字声明代码包的语句必须位于文件开关（注释除外）。

最简单完整的程序

现在，所有基础的东西都讲的差不多了，我们可以写一个稍微完整一点的示例了。按照业界通例，最简单最完整的程序就是Hello World：

package cn.ms11;
// MyHelloWorld.java
public class MyHelloWorld {
    public static void main(String[] args) {
        System.out.println("MyHelloWorld.main 方法");
    }
}

这段程序中的几个知识要点： - 包声明，这个之前已经说过了 - 类，一个文件中有且仅有一个public访问权限的类，文件名称和类名称一致，这个之前也说过了，有main方法的类必须是public访问权限 - main方法，这是Java程序的入口，计算机从此处开始执行代码，main方法退出了，程序也就结束了，main方法的声明必须是这样的，不能修改 - main方法中的args，是执行Java程序的时候传进来的命令行参数

Java对象和OOP

之所以将Java中的对象单独拿出来说，是因为这里有一些我们后面会多次接触到的一些共性知识，所以有必要强调一下。

面向对象编程OOP

Java是一门面向对象的编程语言，它的代码中，只有类，没有单独的函数，每个类中，又有许多成员，如此完成对现实世界的抽象和描述，因此有人称其最最激进的面向对象编程（Object Oriented Programming，OOP）。因此，在这里我们有必要再简单了解一下什么是面向对象编程。

面向对象编程有三大特性：

• 继承，继承，就是父类子类的继承关系，又称基类和派生类，这个前面我们已经介绍过了。
• 封装，封装的基本思想是对访问开放、对修改关闭，并且坚持最小开放原则。对访问开放、对修改关闭，指的就是getter和setter，外部访问经过统一出入口进行管理，可以避免内部过多的细节暴露，最小开放原则，就是指能不开放的，就不开放，必须要开放的，才开放。比如我们用一个类完成了对一种现实世界中的事物的抽象，它有很多字段用于描述事物的属性和状态，还有很多方法用于描述事物的行为和动作，这种情况下，就没有必要全部开放出去，需要哪个开放那个即可。
• 多态，多态是指父类有多个子类的时候，代码可以在运行期间动态的决定执行哪个类，而不是编写代码的时候就已经写死了固定了。

关于多态，因为实践中应用很多，我们有必要举例子再做一个说明：

abstract class Father {
    abstract void sayHello();
}
class SonA {
    void sayHello() {
        System.out.println("SonA sayHello");
    }
}
class SonB {
    void sayHello() {
        System.out.println("SonB sayHello");
    }
}

测试代码：

class PolymorphicTest {
    public static void main(String[] args) throws Exception {
        Father father = null;
        Scanner sc = new Scanner(System.in);
        String son = sc.nextLine();
        if (son.equals("a")) {
            father = new SonA();
        } else if (son.equals("b")) {
            father = new SonB();
        } else {
            throw Exception("无法识别的输入");
        }
        father.sayHello();
    }
}

针对这段代码，在开发期间，我们是不知道运行时的状态的，只有运行时，才能知道用户输入的是什么，然后决定是执行SonA的方法、SonB的方法，还是无法处理时抛出异常。

我们再来解释一下面向对象编程中非常常见的重载、重写、覆盖的概念。

• 如果父类存在该方法，子类也存在同样的方法，我们称之为重写（Override），即：子类重写了父类的方法
• 如果一个类中存在两个相同名称的方法，我们称之为重载（Overload），此时两个方法的参数类型和数量不能完全一样，否则代码就区分不出来了
• 子类重写了父类的方法，我们就称父类的方法被覆盖了

对象与内存布局

我们先看JVM的内存模型，来张从网上找到的图：

解释这张图之前，我们先说说什么是线程，线程是一个非常复杂的东西，我们后面还有专题学习，这里先简单说一说。线程就是计算机的CPU的一个执行单元，每当我们想让计算机完成一项任务的时候，我们就可以将这些任务的若干个步骤放在一起，打包成一个执行单元，统一交给CPU去执行，这就是线程。很明显，CPU要承接很多个任务，那就会有很多个线程，问题是，对于单核CPU而言，它其实在一个时刻只能执行一个任务，所以，CPU会给每个线程分配一点点时间（称为时间片），这一点点时间过了之后，再执行下一个线程，然后再照此法执行后面等待的其他线程，如果完成所有线程的调度，这个时间是非常短的，所以给使用计算机的人的感觉就是CPU同时完成了很多任务（比如边下载文件边播放音乐，我们既不会看到下载中断也不会发现音乐播放中断）。对于多核CPU而言，优势是各个内核可以分别开始执行自己的线程队列中的线程，感觉性能一下子就提升了很多，但是新的问题出现了，多个线程很多时候会竞争一个资源，比如多个线程同时往磁盘中写入文件，而磁盘只有一个，磁盘控制器也没有一个，磁盘的缓存也只有一个，在某些情况下，还会出现线程B必须等待线程A完成之后，从线程A得到某个结果再做某事，这些都涉及到线程同步和线程锁的问题。所以，线程的调度是一件非常复杂的事情，我们以后再详细学习。

初步了解了什么是线程之后，我们就说说这个JVM内存模型，我们往简单了解释：

1. Java程序启动，创建一个主线程，主线程给自己开辟一块内存空间，用于保存线程运行期间的数据，这块内存称为栈，栈的空间一般很小，1MB到2MB
2. 线程在运行的过程中，又创建了其他线程，称为子线程，这些子线程和主线程没有任何区别，同样需要自己的线程栈。由此可知，每个线程都有自己的线程栈
3. 线程在执行某个实例的方法时，会开辟一块内存空间，用于保存该方法执行期间的数据（比如方法中的局部变量、返回值等），这个称为方法栈
4. 某个实例的方法执行完毕返回了，刚才的方法栈就要释放，内存空间回收

上面这个过程，就是Java中线程执行代码的过程，但是这里有个问题要统一回答：线程栈是很小的，一些很大的对象（比如一个列表，里面有10万个元素），很明显在栈上放不下，所以Java又在整个JVM进程启动的时候，在系统内存中专门申请了一块很大的内存空间，用来存放这些大对象，这就是堆，然后代码在运行时，栈上用变量保存堆中的大对象的地址，通过变量的值就可以找到堆中的大对象了。现在，它们的特点很明了了：

• 栈，运行时动态创建、动态回收，很小，所以创建和回收都很快，里面主要存放的是局部变量（当然，还有其他一些东西）和一些基础类型（int、boolean等）的数据，栈是线程内部专用的
• 堆，JVM启动的时候创建，很大，所以创建和回收相对栈来说是慢一些的，里面主要存放的是各种对象，尤其是比较大的对象，堆是所有线程共享的（所以在某些情况下多个线程同时修改一个数据时会出现冲突问题，这个以后再说）

线程运行的时候，在堆中创建了一个对象，然后再在栈上创建一个对象保存堆中该对象的地址，由此完成对大对象的处理，等线程结束了，栈上的保存堆对象地址的变量就会消失（因为该线程的栈空间被回收了），但是堆中的对象仍然存在，此时如果堆中占用的对象不销毁、占用的空间不回收，程序长时间运行、反复这样做，就会将内存空间耗尽，这肯定是不可以的。所以JVM有一套内存回收机制，当它发现堆中的对象没有任何其他对象保存了它的地址时（也就是再也没有人能够访问到它），就对它进行回收，这就叫垃圾回收，英文Garbage Collection，简称GC，JVM中有专门做这件事情的线程，我们通常称其为GC线程。

注意，在Java中，char、byte、int、long、float、double、boolean等这些基础类型（系统内置的、用小写字母表示的）的值，是保存在栈上的，其他的类型创建的值，都放在堆中，包括这些基础类型的包装类型Byte、Integer、Long、Float、Double、Boolean以及String类型和开发者自定义的数据类型。那么Java为什么要这么设计呢？这是因为基础类型的大小是固定的，栈空间处理这些固定大小的数据可以充分发挥性能优势还能避免GC，是非常好的设计，同样的，包装类型因为要和其他大小会变动的数据类型一起完成对现实世界的表达和抽象，自然就得在堆上了。

Java对象

现在，我们可以解释Java中对象的问题了，先看一段代码：

public class EqualsTest {
    public static void main(String[] args) {
        Integer a = new Integer(5);
        Integer b = new Integer(5);
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

上述代码中有一个equals方法，下面我们也着重介绍一下。在Java中，基础类型如int、boolean，是可以直接使用==判断它们是否相等的，但是对于包装类型、字符串类型和用户自定义的对象类型，是不可以的。对象类型的变量，==只能表明它们是否是同一个实例，却不能表明它们的值是否相同。请看下面的代码：

public class EqualsTest {
    public static void main(String[] args) {
        String a = new String("beijing");
        String b = new String("beiJing");
        System.out.println(a == b);
        System.out.println(a.equals(b));
    }
}

上面的代码和前面两个Integer类型的变量a和b的逻辑是一样的，都是第一个输出false第二个输出true。原因就是a和b都是new出来的变量，像Integer和String，它们都是在堆上的，所以它们肯定是有不同的内存地址的，a和b的值分别是它们的地址，那肯定是就不相等了，所以输出false，第二个调用的equals方法，就是将变量所指向的堆中的对象的值取出来进行比较，它们的值都是beijing，于是就输出true。

异常

异常机制

异常是指程序在运行的过程中出现的非预期场景，比如正在从网络下载文件，突然断网了，正在读写文件，突然文件被其他进程给删除了，正在读取U盘上的文件，突然U盘被人拔出了等等。当然，也包括一些相对前述这些“故障”级的异常而言没这么“严重”的情况，比如用户输入的两个数要相除，但是除数是0，此时无法进行进一步的计算，也算是异常。Java中的异常，体系如下：

如上图所示，Java中的异常有两大类：

• Error 这种异常，通常是无法处理的，会导致进程完全崩溃，但是通过一些配置项，可以获得程序崩溃的一些详细信息，便于我们排除错误。这里最常出现的就是内部不足：OutOfMemoryError，业界通常简称为OOM。
• Exception 这种异常，如果代码中不捕获和处理，程序也会崩溃退出，如果在代码中予以必要的捕获和处理，则可以避免程序崩溃退出。例如用户输入了一个日期，但是我们的程序无法识别它的格式，可以捕获这种异常，然后提示用户输入不正确，请重新输入之类的信息。就能避免因为用户一次错误的输入而导致各个程序崩溃退出。

默认情况下，一旦程序出现异常，那么将会从出现异常的位置直接退出，该位置之后的代码将不会被执行。

抛出或声明异常

除了程序在运行中出现的各类异常，我们还可以在代码中手动抛出异常。代码也很简单：

throw new Exception();

throw关键字后面写一个Exception类或它的子类的实例对象，就可以抛出异常了。

在声明一个方法时，如果方法中有Exception抛出，那么该方法的定义部分要用关键字throws明确声明该方法可能有异常，让调用者知道并做一些必要的处理：

// 声明此方法在执行时有可能抛出两个异常
public static void method1() throws IOException, FileNotFoundException {
    //something statements
}
// 声明此方法在执行时有可能抛出Exception异常
public static void method2() throws Exception {
    //something statements
}

捕获异常

前面我们也提到了，Exception这种异常可以被捕获，那么具体怎么做呢？很简单的，使用try…catch就可以了，有其他编程语言经验的同学们肯定也已经想到了，下面我们一起来看一下吧：

try {
    File f =new File("C:\\test.txt");
    FileInputStream fis = new FileInputStream(f);
    // todo something
} catch (FileNotFoundException e) { //子类异常
    e.printStackTrace();
} catch(IOException e) {  //父类异常
    e.printStackTrace();
} catch(Exception e) { //基类运行时异常
    e.printStackTrace();
}
System.out.println("continue");

在上述代码中，我们试图读取C:\test.txt这个文件，如果这个文件不存在，将会抛出FileNotFoundException，如果读取文件的过程中出现错误，将会抛出IOException，如果还有其他无法处理的异常，将会抛出Exception，这些我们都要捕获并处理掉，才能不让我们的程序崩溃退出。此时程序在执行完相关异常的catch代码块中的e.printStackTrace之后，将会继续往下运行，会打印输出continue，不会崩溃退出。

👉👉👉注意： 上述代码中的这三个异常，它们是有继承关系的，IOException是Exception的子类，FileNotFoundException是IOException的子类，所以，有多个catch代码块的时候，子类一定要写在前面，父类一定要写在后面。

因为我们已经通过异常机制的章节知道，所有非Error类型的异常都是Exception的子类，那么上述代码可以简化：

try {
    File f =new File("C:\\test.txt");
    FileInputStream fis = new FileInputStream(f);
    // todo something
} catch(Exception e) {
    e.printStackTrace();
}

即：如果某段代码执行时可能会产生多个异常，我们可以只捕获这些异常共同的父类（其实就是Exception了）。

在实际的应用软件开发中，如果出现异常，我们通常会将异常信息收集起来（通过catch块中的实例e的相关方法调用可以做到），然后记录在日志文件中或者某个地方，便于我们以后排查处理。

finally语句块

无论是否有异常，finally块中的代码总是会被执行的。 finally语句在执行关闭资源的语句时非常有用。如：无论读写文件是否出现了异常，我都选择将文件关闭，否则程序运行的时间一长，方法被调用的次数一多，就会出现文件被打开了许多份，就会造成资源泄漏和浪费，甚至是内存耗尽。

第一种形式：

try {
    // 要执行的程序代码，可能会出现异常
} catch(Exception e) {
    // 出现捕获时执行的代码，走到这一步，说明异常已经被捕获
} finally {
    // 无论是否异常，一定会执行的代码
}

第二种形式：

try {
    // 要执行的程序代码，可能会出现异常
} finally {
    // 无论是否异常，一定会执行的代码
}

finally语句块很有用，在做一些需要加锁的操作时很有用，比如在做支付扣款操作时，要锁定账户，然后判断余额足够时才扣款，这样才能防止多个操作同时进行以至于把账号余额扣成负数。这个操作可以在刚进入try时加锁，然后在finally块中释放锁（如果不释放锁，会导致该账户被永久锁定，谁也用不了了，明显是不可以的）。

Maven简介

Maven是Java开发必备的一款依赖管理和代码构建工具。这么说是不是太抽象了？我们从问题的角度入手，做复杂的、大型、超大型软件开发的时候，有这么几个非常觉的问题：

• 依赖管理，比如我要做一个Redis数据库的连接池，让我基于Java语言现开发肯定是不太合适的，如果有现成的、别人开发好，直接用，他不香吗？要实现这个依赖自动管理，就又引申出一个新的问题：依赖的版本，这同样需要依赖管理工具帮助我们做，否则一个软件中引入多个版本的第三方代码库（包），很容易出现各种冲突和错误
• 构建编译，在软件开发的过程中，我们经常要写一点，编译运行一下，看看有没有问题，有问题就赶紧改，没有问题再继续写（如果你一口气写完整套软件，比如花了半个月，然后发现有问题再重新写？想想吧😒）。在这个过程中，反复保存、编译、运行、调度，这个过程太浪费时间、太痛苦了，我们必须要有一套自动化的工具，把我们的这个过程一键完成
• 代码组织规范，这其实是一个团队协作的问题，一个大型、超大型的软件，一定是很多人一起开发的，那么所有人都应该遵循一套规范，否则一个软件系统中五花八门的岂不是乱套了，还怎么组织代码？以后还要不要维护了（根据笔者的经验，新写代码的时间一般只占开发者20%的时间，剩下的时间都是在维护和修改😂）。
• 代码分析和检查，这其实是一个软件质量的问题，软件开发的过程中，我们要不断的对代码进行分析和检查，避免一些质量低下的代码被提交和编译运行，这会导致各种BUG，坑很深哦~

基于以上原由，我们是必须要有一套依赖管理和代码构建工具，才能高效地完成Java软件开发工作。而目前主流的就两个：Maven、Gradle，Maven在传统的Java开发中用的很多，Gradle也有人用，但更多的是用在Android开发中。

Maven安装配置

Maven的安装非常简单，只需要下载官方提供的压缩包，然后解压，最后再配置两个环境变量就可以了：

• MAVEN_HOME 指向具体的Maven软件包的目录
• MAVEN_OPTS 可选，用于指定Maven运行时的内存占用策略，配置方法和JAVA_OPS一样的，示例：-Xms512m -Xmx1024m

最后，将MAVEN_HOME目录下的bin目录添加到系统环境变量中：

• 在Windows下，就是将%MAVEN_HOME%\bin添加到环境变量Path中，需要在系统设置中去修改，然后新开cmd或PowerShell才能生效
• 在非Windows系统下，就是将$MAVEN_HOME/bin添加到环境变量PATH中，在~/.bashrc中配置并导出即可，完成后运行命令source ~/.bashrc使其立即生效

安装好之后，可以在命令行执行mvn命令，就能验证是否安装成功了（注意：Maven依赖于JDK，必须得先安装好JDK才能用Maven）：

IDE与Maven协作

IDE是集成开发环境（Integrated Development Environment）的简写，通常是指具备软件工程化管理功能、代码编辑功能、编译运行、调试排错等综合功能的软件，对于Java开发来说，市面上最常见的两款IDE是开源的Eclipse和JetBrains的IDEA，前者是开源软件Eclipse基金会的，后者是一家专门为程序员开发各种IDE的厂商开发的商业化软件，IDEA只是其中之一。

这两款IDE，都内置了Maven，当然，我们也可以使用在操作系统中安装的我们自己的Maven，而且笔者更喜欢这么做，原因有如下： - IDE内置的Maven，修改配置需要在IDE中，如果IDE更换或卸载重新安装，配置会丢失 - IDE内置的Maven，跟着IDE走，需要我们再额外地去掌握它的配置和使用，比较麻烦，而使用自己的，固定一个版本和一套配置，省事 - 特殊情况下，我可以修改我自己的Maven中的配置甚至代码，让它的工作符合我的预期，对于IDE中自带的Maven，那就没把握能修改了

对于Eclipse，只需要点击Window菜单，再点击Preferences，在里面找到Maven，就可以调整它的配置了，很简单的。

对于IDEA，其实也差不多，打开Settings之后，找到Build、Execution、Deployment，下面有个Build Tools，再下一级，就有Maven，调整它的配置就可以了，也很简单。

Maven使用简明教程

Maven配置文件

Maven的配置文件位于Maven安装目录中的conf目录下，名叫settings.xml。

注意：这里的配置文件中的项，会对使用这个Maven的所有软件工程生效。

它里面有这么几个重要项，我们分别解释一下：

• localRepository 下载的外部依赖保存到什么地方，默认是${user.home}/.m2/repository，按照我的个人在Windows上的习惯，我会把它挪到其他地方去，这可就可以避免如果我重装系统了，还要重新下载一遍
• servers 私服发布的账号和密码，这个配置一般在服务器上使用，在我们开发机器上一般不配置，通常的做法是：在Jenkins服务器或CI/CD服务器上配置好，然后打出来的包会直接进入公司自建的私服仓库，便于其他人使用
• mirrors 获取外部依赖的镜像位置，如果不配置，默认从官方仓库获取，在官方国外，很慢的，通常我们会在这里配置多个mirror，国内的阿里云、公司自建的私有仓库等
• profiles 个性化配置，也可以配置多个，我个人的经验是：先配置一个profile，指定JDK版本，比如JDK8，再配置其他仓库的地址，便于我们能从其他仓库下载依赖包
• activeProfiles 这个其实就是指定激活前面的profiles中配的个性化配置，当profiles中指定了多个配置的时候，可以在这里指定激活哪一个，通常，全局性的个性化配置我们才会在这里指定，其他的通常在软件工程中配置，否则会导致不同的软件工程使用个性化配置出现问题

下面贴一份示例配置：

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">

    <!-- 本地仓库的位置 -->
    <localRepository>D:\repository</localRepository>
    
    <!-- 阿里云镜像 -->
    <mirrors>
        <mirror>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>https://maven.aliyun.com/repository/public/</url>
            <mirrorOf>central</mirrorOf>
        </mirror>
    </mirrors>

    <!-- 配置: java8, 先从阿里云下载, 没有再去私服下载  -->
    <!-- 注意: 影响下载顺序的是profiles标签的配置顺序(后面配置的ali仓库先下载), 而不是activeProfiles的顺序 -->
    <profiles>
        <!-- 全局JDK1.8配置 -->
        <profile>
            <id>jdk1.8</id>
            <activation>
                <activeByDefault>true</activeByDefault>
                <jdk>1.8</jdk>
            </activation>
            <properties>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
            </properties>
        </profile>
        
        <!-- Nexus私服配置: 第三方jar包下载, 比如oracle的jdbc驱动等 -->
        <profile>
            <id>team</id>
            <repositories>
                <repository>
                    <id>nexus</id>
                    <url>http://192.168.10.112:8081/nexus/content/groups/public/</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>true</enabled>
                    </snapshots>
                </repository>
            </repositories>
            <pluginRepositories>
                <pluginRepository>
                    <id>public</id>
                    <name>Public Repositories</name>
                    <url>http://192.168.10.112:8081/nexus/content/groups/public/</url>
                </pluginRepository>
            </pluginRepositories>
        </profile>
        
        <!-- 阿里云配置: 提高国内的jar包下载速度 -->
        <profile>
            <id>ali</id>
            <repositories>
                <repository>
                    <id>alimaven</id>
                    <name>aliyun maven</name>
                    <url>https://maven.aliyun.com/nexus/content/groups/public/</url>
                    <releases>
                        <enabled>true</enabled>
                    </releases>
                    <snapshots>
                        <enabled>true</enabled>
                    </snapshots>
                </repository>
            </repositories>
            <pluginRepositories>
                <pluginRepository>
                    <id>alimaven</id>
                    <name>aliyun maven</name>
                    <url>https://maven.aliyun.com/nexus/content/groups/public/</url>
                </pluginRepository>
            </pluginRepositories>
        </profile>

    </profiles>
    
    <!-- 激活配置 --> 
    <activeProfiles>
        <activeProfile>jdk1.8</activeProfile>
        <activeProfile>dev</activeProfile>
        <activeProfile>ali</activeProfile>
    </activeProfiles>
</settings>

你可以参照这份配置，做一些研究和修改，很容易就能自己用了。

通过Maven创建项目

在我们使用IDE的时候，通常我们都是使用IDE自带的创建项目的功能来新建一个软件工程，但是实际上它们仍然是通过Maven的这一套机制创建的。

创建普通的Java项目：

mvn archetype:generate -DgroupId=cn.ms11 -DartifactId=demo -DarchetypeArtifactId=maven-archetype-quickstart

创建一个Java Web项目：

mvn archetype:generate -DgroupId=cn.ms11.blog -DartifactId=myweb -DarchetypeArtifactId=maven-archetype-webapp

• mvn 是Maven的命令
• archetype:generate 是表示创建一个项目，archetype其实是原型的意思，表示Maven内置了很多原型模板（预定义好的项目模板），可以基于它们创建我们自己的项目
• -DgroupId 项目的组名称，按照Java开发约定，每个Java项目，都会有一个groupId
• -DartifactId 项目的制品输出名称，按照Java开发约定，每个Java项目，都会有一个唯一的artifactId，如果这个项目是你自己用的，随便起无所谓，如果是要和他人协作，就要起名专业、见名知义，如果是作为公开软件发行，就一定要起一个正式的、正确体现产品功能的名称，最好能做到唯一
• -DarchetypeArtifactId 引用的模板名称，这些模板，其实也是Java项目，只不过我们是照着他们的“模子”复刻了一份我们自己的，所以这些模板也会有artifactId，在这里，普通的Java项目我们引用的模板是maven-archetype-quickstart，Java Web项目我们引用的模板是maven-archetype-webapp，大家注意这两个名字，以后我们还会经常和他们打交道。

普通的Java项目和Java Web项目有什么区别呢？普通的Java项目，顾名思义，就是它没有什么特别的，就是我们常规的一些Java类放在一起，然后写一个main方法，让它能够启动并执行，这是基于J2SE的，Java Web项目就不同的了，它是基于J2EE的、用于服务器端软件开发的一门技术，又称为企业级应用开发，这种开发技术比普通的Java开发要复杂的多，它要处理数据库中的数据、要开放服务给用户来访问网站，当网站用户量比较大的时候，还要想办法通过缓存提升性能等等。 J2EE是Java Web开发的一整套规范，这一整套规范共有13项，分别是：

• JDBC（访问数据库的，用的很多）
• JNDI（访问服务器资源的）
• EJB（业务逻辑抽取方法，用的人已经很少了）
• RMI（远程访问调用，仍然有很多老旧项目在用）
• JavaIDL（公用对象请求体系，用的也不多）
• JSP（曾经的网站页面开发，也就是Web开发的王者，现在已经没落了）
• Java Servlet（在服务器上处理请求、扩展服务器应用程序的能力，很常用）
• XML（一种数据描述语言，也挺常用的）
• JMS（Java消息服务，部分细分领域用的人挺多的）
• JTA（分布式事务，比较常用）
• JTS（事件监控，笔者也没用过）
• Java EMail（发邮件的，OA等系统中挺常用）
• JAF（数据处理框架，用的很少，现在的数据都有专门的数据仓储平台和框架）

关于J2EE的规范，了解一下就可以了，等你对Java Web的开发技术已经掌握的差不多的时候，再回过头来研究这些规范，会有更多的收获。

通过Maven打包

Maven打包是非常简单的：

mvn package

一个Java项目，可以被打成jar包或war包两种格式，具体打成什么，是由项目根目录下的pom.xml决定的。这个pom.xml的具体配置和用法，我们后面会学习到。

说起打包指令，我们还要顺便提一下安装指令和部署指令，安装指令：

mvn install

部署指令：

mvn deploy

这两个指令分别有什么用呢？这就要提到最开始我们学习Maven的时候说的Maven仓库了，Maven仓库本质上是一个OSS，也就是对象存储服务，大家把自己开发的各类软件组件、框架、类库上传到Maven仓库，就可以让其他人使用了。简单地说，Maven有四类仓库：

• 中央仓库，官方地址：https://mvnrepository.com/ ，在美国。所以访问和下载各种依赖都很慢。
• 镜像仓库，世界各地针对中央仓库的问题，都建立了本地化的镜像，在国内用的最多的是阿里云镜像，前面介绍Maven配置的时候提到的settings.xml中就有
• 私服仓库，私服仓库是针对企业内部使用的，一个企业内部有多个团队多人协作时，也需要解决某个团队开发的组件给其他团队使用的情况，也需要将这些组件上传到自己企业的私有仓库中便于他人随时下载和使用。私服仓库需要各企业自行搭建，最的最多的是Nexus，Nexus软件的官方地址：https://www.sonatype.com/products/repository-oss
• 本地仓库，这个是指Maven在运行时本机上保存的第三方依赖，Maven在打包时，会将第三方依赖下载下来放到本地仓库，然后直接从本地仓库读取使用。这个本地仓库，其实就是在本地磁盘上指定一个目录用于保存这些第三方依赖。具体的位置是在Maven的settings.xml中通过节点localRepository指定的。

通过Maven执行测试

执行Maven的打包命令的时候，默认是会执行代码中的测试代码（就是位于src/test/java下的单元测试用例代码），所以，一般情况下如果我们写了测试的代码，更多的时候，是在某些情况下不执行测试，直接出包。具体指令：

mvn package -DskipTests

上述指令，不会执行测试代码，但是仍然会编译测试代码，如果我们既不想执行测试代码，也不想编译测试代码，那么可以使用下面的指令：

mvn package -Dmaven.test.skip=true

通过Maven清理编译信息

某些时候，我们想要把编译出来的字节码、配置等相关内容全部清理掉，然后重新开始编译打包，指令也很简单：

mvn clean

pom.xml文件简介

pom文件是Java开发中非常重要的一个文件，一个软件工程，必定有一个pom.xml文件，这是工程的配置文件，工程相关的基础信息（名称、groupId、artifactId等）、变量、第三方依赖、打包、测试等等的相关配置信息，全部都在这个文件中配置。在介绍pom.xml文件之前，先明确一个Maven管理软件代码的方式：一个复杂的规模庞大的软件系统，它通常会有很多个模块，这些模块有可能还有子模块，像这种树状的结构，Maven也可以很好的管理和组织起来，其实就是父模块、兄弟模块这样的逻辑关系，无论是父模块还是子模块，都会有一个Maven的pom.xml文件，并且会在这个文件中声明它们的父是谁、子有哪些。

我们先来个pom文件的模板示例，然后配合注释进行说明：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
            http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <!-- 基本设置 The Basics -->
    <groupId>...</groupId>
    <artifactId>...</artifactId>
    <version>...</version>
    <packaging>...</packaging>
    <dependencies>...</dependencies>
    <parent>...</parent>
    <dependencyManagement>...</dependencyManagement>
    <modules>...</modules>
    <properties>...</properties>
    
    <!-- 构建过程的设置 Build Settings -->
    <build>...</build>
    <reporting>...</reporting>
    
    <!-- 项目信息设置 More Project Information -->
    <name>...</name>
    <description>...</description>
    <url>...</url>
    <inceptionYear>...</inceptionYear>
    <licenses>...</licenses>
    <organization>...</organization>
    <developers>...</developers>
    <contributors>...</contributors>
    
    <!-- 环境设置 Environment Settings -->
    <issueManagement>...</issueManagement>
    <ciManagement>...</ciManagement>
    <mailingLists>...</mailingLists>
    <scm>...</scm>
    <prerequisites>...</prerequisites>
    <repositories>...</repositories>
    <pluginRepositories>...</pluginRepositories>
    <distributionManagement>...</distributionManagement>
    <profiles>...</profiles>
</project>

• 基本设置，这个很重要，每个工程都要配置，这个是重点，具体有以下几项
  • groupId 你可以理解项目分类或分组的唯一标识符、ID，父模块中必须指定，子模块中通常不指定，直接使用父模块的。
  • artifactId 构建出的成品的唯一标识符、ID，必须指定。
  • version 构建出的成品的版本号，父模块必须指定，子模块中通常不指定，直接使用父模块的。
  • packaging 打包方式，有三个最常用的值：pom、jar、war，以Maven方式创建的软件工程，如果软件很复杂，就需要拆分成很多个模块，这些模块可以统一使用父模块管理它们的依赖（当然，也支持多级继承，但是通常两三级也就够了），所以，对于父模块的pom.xml中的packaging，就应当指明为pom，普通的Java工程或不独立运行而是供他人使用的模块，通常都指定为jar（即：打jar包），传统的基于SSH或SpringMVC框架开发的Java Web项目，通常声明为war（即：打war包）。一般情况下，要独立地、直接运行的Java代码都会打为jar包（当然了，它里面要有一个main方法才可以），如果打为war包，通常会将打出来的包放到Tomcat（一款非常流行的Web应用程序容器）中运行。packaging如果没指定，默认为jar。
  • dependencies 依赖定义，如果工程中使用了其他组件，就要在这个节点下定义。dependencies节点下可以有多个dependency，每个dependency是一个依赖项，每个依赖项还有几个重要的参数项：
    • optional 用于控制依赖传递，假设A依赖B，B又依赖C，此时在A的pom.xml中引用B的依赖时，如果optional为true，则A只依赖B而不依赖C，如果optional是false，那么表示A依赖B同时也依赖C
    • scope 用于控制依赖项的引用方式，默认值是compile，表示对依赖项进行编译并且打入目标包中，取值provided，表示使用依赖项，但是不打入目标包中（通常这种情况是由目标应用容器如Tomcat提供，所以见的多的是servlet的包用这种方式引用），取值runtime，表示运行和测试时需要该依赖，但打包时不需要，取值test表示编译和测试时都不需要，只在测试编译和测试运行时需要，取值system，表示从本地引用一个依赖的jar包，很少用，因为限制太多
  • parent 这个对于子模块是必须的，用于指定本工程的父模块，这个配置项对于单独的Maven工程没什么意义，在现在SpringBoot框架的开发模式下，也可以通过继承SpringBoot官方定义的父模块快速地完成子模块的定义和配置，大大简化自己手动配置工程的每一个细节的过程，效率提升非常明显。
  • dependencyManagement 依赖声明，注意，这个只是依赖声明，它和dependencies是不一样的。dependencies会将定义的依赖引入本工程中，是可以直接使用的，而dependencyManagement仅仅是声明本工程要使用某个依赖项，却并不会真正引入本工程。所以这个dependencyManagement通常是在父模块中使用。在父模块中声明使用哪些依赖，然后在子模块中按照父模块的声明通过dependencies进行依赖定义，这样就可以实现多个子模块的依赖管理统一到父模块中了，便于解决一些版本冲突等问题。通常情况下，一个复杂的软件工程，如果引入第三方依赖，应该统一版本号，防止各行其是，那样很容易出现各种各样的问题。
  • modules 子模块声明，仅对父模块有用力，在父模块中，有哪些子模块继承了自己，要在这里声明出来，它和parent相对应，子模块中通过parent指明父模块是谁，父模块中通过modules指明都有哪些子模块，只有对应得上，才能编译打包成功。
  • properties 变量声明，如果软件工程的配置中存在一个值多处使用的情况（通常是第三方依赖组件的版本号），我们就可以通过这个节点进行统一声明，避免到处写、到处维护的情况。
• 构建过程，只需要做一些必要的设置即可，不设置的情况下也有默认值。
• 项目信息设置，这个通常是开源项目才设置，企业内部项目一般都不设。
• 环境设置，这个通常是在一些特定情况下使用的，比如大型开源软件基金会发布和管理的软件项目上。

Maven工程的pom文件里面的知识点还是非常多的，配置项也很多，我们在这里先学习这些，在后面的开发学习中，我们会逐步接触到更多的相关用法。

🍬 使用Maven管理Java代码工程是使用的最广泛的一种方法，它的最基本的实践套路是：当我开发软件的时候，需要一个特殊的功能（比如密码加密、校验手机号码、发送网络请求、访问数据库等等），我不需要自己从头开始一行一行写代码，我去找一个第三方框架，别人已经写好的，直接拿来用（Java开发中最强大的Spring框架就带了这方面的很多很多功能）。要想把别人写好的东西拿来直接使用，不是将对方的代码拷贝到自己的软件代码包中，而是在自己工程的pom中的dependencies节点或dependencyManagement中写上对方的依赖项，将对方引入到自己的软件工程中来就可以了。那么，对方的依赖上哪儿去找呢？Maven的中央仓库里是最全最完整的，官网站点：https://mvnrepository.com/ 或者你觉得访问这个网站太慢，你还可以通过搜索引擎的关键字maven repository都能找到Maven仓库，去仓库中搜，还可以去技术博客、社区和其他人交流，都能快速掌握这些技能，找到优质资源。

Maven插件使用

Maven本身仅仅拥有一个具备高度灵活和可扩展的软件架构，但是在编译打包的过程中，还有很多事情要做，比如是否将源代码也打到包里、是否生成javadoc、是否自动生成一些代码之后再打包等等。在这方面，官方提供了很多插件，方便我们打包，当然，我们也可以自己开发插件实现更复杂的功能。这里我们就先说说怎么使用插件吧。 > javadoc是指将Java代码中的注释生成HTML，便于其他开发人员阅读和理解代码。

在Maven项目上使用插件，具体做法是修改项目的pom.xml文件，示例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring.boot.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>package</goal>
                    </goals>
                </execution>     
            </executions>
        </plugin>
    </plugins>
</build>
</project>

上面这个配置文件，是指定了插件spring-boot-maven-plugin，这个插件是用来编译打包SpringBoot工程的，当然如果有多个插件，就在plugins节点下再增加plugin节点，如法炮制即可。还可以插件节点下的glals中配置多个goal，Maven中常用的goal是archetype、compile、test、jar、install，看名称就知道了它们是做什么的了（Maven中的goal是一个比较复杂的话题，其中还激活到Maven管理项目的生命周期的问题，这属于高级话题，我们可以以后再学）。

字节码

我们所写的Java源代码文件是这样的：

package com.wasu.t.c;

public class CodeFileDemo {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

编译后的字节码文件是这样的：

最开头的那几个字符CA FE BA BE，通常被称为“魔数”，是JVM识别.class文件的标志，不符合这种标志规范的，它不会加载。

我们还可以反编译这些.class文件，在.class文件所在位置执行下面的指令：

PS E:\code\ideaWorkspace\test-any\target\classes\com\wasu\t\c> javap -c -l .\CodeFileDemo.class

看看它到底是怎样的字节码信息：

Compiled from "CodeFileDemo.java"
public class com.wasu.t.c.CodeFileDemo {
  public com.wasu.t.c.CodeFileDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
    LineNumberTable:
      line 9: 0
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0       5     0  this   Lcom/wasu/t/c/CodeFileDemo;

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String Hello World
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
    LineNumberTable:
      line 11: 0
      line 12: 8
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0       9     0  args   [Ljava/lang/String;
}

每个字节码指令，都有它特定的含义： - 第3行，是默认的构造方法，当我们没有为类指定时，编译器会自动添加一个 - 第5行aload_0，是从本地变量表中加载索引为0的变量的值，也就是this，然后压入栈 - 第6行invokespecial，出栈，调用java/lang/Object."<init>":()V初始化this指定的对象，具体就是调用this指向对象的init方法 - 第8行LineNumberTable，指令与代码行数的偏移对应关系，每一行有两个数字，第一个是代码行数，第二个是前面Code节中的的指令前面的数字，本例中，line 9: 0的意思是：代码的第9行就是本字节码文件中的Code节中的0，也就是aload_0（这一小段文本中的第5行） - 第10行LocalVariableTable，局部变量表，本例中，只有this这一个变量

其他详细信息我们以后再说。

类加载过程

JDK的类加载过程如下图所示：

如图，加载、验证、准备、初始化，这四个阶段的顺序是固定的，解析，在某些情况下，解析可能在初始化之后开始，这样做是为了支持Java的运行时绑定（也称为动态绑定或晚期绑定）。

• 加载（Loading），这是类加载过程的第一个阶段，主要是将字节码从不同不的源（class文件、jar包、甚至网络字节流等）加载到内存并生成一个代表该类的java.lang.Class对象
• 链接，这是类加载过程的第二个阶段，分为验证、准备、解析三个步骤
  • 验证（Verification），是为了确保被加载的class文件是符合JVM规范的，否则会导致一些意外情况和安全问题，主要包括四种验证：文件格式、元数据、字节码、符合引用，总之，是为了确保被加载类的正确性
  • 准备（Preparation），是为类的静态变量分配内存，并将其初始化为默认值（如：有static int a = 5这样的语句，此时a的值是int的默认值0，经过了后面的初始化阶段之后它的值才会变成5），但不包含final修饰的static变量，因为final修饰的变量是在编译期确定的。此外，类变量在JDK7及以前会分配到方法区中，JDK8及之后会分配到Metaspace中，实例变量会分配到Java堆中。
  • 解析（Resolution），把常量池中的符号引用转换为直接引用。这句话的意思是：类com.A引用了类com.B，在编译阶段，类A并不知道类B的地址，所以，在类A中对类B的引用，只能描述为com.B，这就是符号引用，而加载类时，因com.B被加载，JVM就知道类B的地址了，此时就需要在类com.A中将类com.B的地址转换成真正的地址（类A对类B的真正的地址的引用，就是直接引用，也只有这样，类A在执行的时候，才能它所依赖的B）
• 初始化（Initialization），这是类加载过程的第三个阶段，主要是为类的静态变量赋予正确的初始值。如果类有父类，就先对父类进行初始化，执行其静态初始化器（也就是用static修饰的静态代码块）和静态成员变量的初始化（对static修饰的类成员变量，在准备阶段已经有初始的类型默认值了，在这里会对它进行赋值，让它的值是源代码中指定的默认值）。类的构造器也会在这个时候执行。

所谓绑定，是指把一个方法的调用和方法所在类关联起来（否则就会出现方法找不到类、类找不到方法的情况），Java中有动态绑定和静态绑定两种： - 静态绑定是在编译阶段就确定的，如果类的方法是final、static、private，那么它就是静态绑定的，构造方法也是静态绑定的，静态绑定也称前期绑定 - 动态绑定是在运行阶段绑定的，是代码运行时根据具体对象的类型进行绑定，非静态绑定的，就都是动态绑定，它占大多数，动态绑定又称运行时绑定

类加载器

通常情况下，我们写一些简单的程序，不需要和类加载器打交道，但是复杂一点的情况下，我们仍然需要使用它们，下面我们就了解一下Java中的类加载器。

首先明确一点：一个类和这个类的加载器一起在一个JVM中确定唯一性。换个说法：同样的一个class文件，使用两个类加载器分别加载，那么它在JVM中是两个Class对象（也就是两个类），调用这两个对象的equals方法会返回false。

Java中有下列加载器： - Bootstrap ClassLoader 有人称之为引导类加载器，负责加载$JAVA_HOME/lib/rt.jar中的所有class文件，由C++实现，这个加载器不是JDK中定义的ClassLoader这个类的子类 - Extension ClassLoader 负责加载$JAVA_HOME/lib/ext/*.jar中的所有class文件，还可以加载由-Djava.ext.dirs选项指定的目录中的jar中的class - App ClassLoader 也称为SystemAppClass，加载当前应用程序的CLASSPATH中的所有class - Custom ClassLoader 用户自定义类加载器

想要知道当前代码的类加载情况，可以尝试运行下面的代码：

public class ShowLoadedClass {

    public static void main(String[] args) {
        ClassLoader loader = ShowLoadedClass.class.getClassLoader();
        while (loader != null) {
            System.out.println(loader.toString());
            loader = loader.getParent();
        }
    }
}

输出结果：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@28d93b30

每个 Java 类都维护着一个指向定义它的类加载器的引用，通过类名.class.getClassLoader()可以获取到此引用；然后通过loader.getParent()可以获取类加载器的上层类加载器。所以，输出结果的第一行是应用类加载器，第二行是扩展类加载器。 > 按照JVM规范，扩展类加载器的上层类加载器是启动类加载器，但在我这个版本的 JDK 中， 扩展类加载器的 getParent() 返回 null。所以没有输出。

!> JDK9之后实现了模块化，类加载器的工作过程和本文表述的不同，但是考虑到目前用的人很少，先不介绍了。

双亲委派机制

双亲委派机制的核心是：当某个类加载器要加载某个类时，该类加载器不直接加载，它会先询问自己的上级类加载器是否加载了，如果上级类加载器已经加载了，就不再重复加载，如果上级类加载器没加载，它自己才加载。

由上述描述可知以下几个关键点： - 防止重复加载同一个.class。通过委托去上级询问，如果加载过了，就不再加载，保证数据安全，也可以避免“其他人写了一个和JDK中的包名类名完全一样的类就能使得JDK不使用自己的类而使用其他人写的类”这种危险的事情 - 保证核心.class不会被篡改，如上一条所示，Java通过固定的方式去加载自己有的类，别人的类是无法“冒充”JDk中的类的，即使篡改了，也加载不了，即使加载了，也不同一个Class对象。这样就保证了Class类的执行安全

动态加载类

动态加载类，是指一个Java程序在编译期间没有的类，在运行期动态加载进来。这种方式，可以实现很灵活的程序功能扩展。例如：我们定义一个接口Flyable，再写一个类Bird实现该接口，然后在代码中设计这样一个机制：运行时，当用户的输入是chicken时，将去指定的目录中加载Chicken这个类并执行它实现了Flyable接口的方法。然后我们将代码发布版本运行起来，运行中，我们动态的编写一个Chicken类并实现Flyable接口，然后将编译好的Chicken.class文件放到指定位置去，然后在程序的输入位置输入chicken，此时，程序不必重启，不必重新发布版本，就可以实现扩展新功能。

在实践中，动态加载类涉及到的问题很多，比如重复加载问题、卸载问题、资源占用问题、引用释放问题等，还是比较复杂的，本文作为初学者文章，大家知道这样的机制，会简单地使用就可以了。

什么是泛型

所谓泛型，简单的理解，就是你在写代码的时候，不知道它是什么类型，它是由程序运行中动态决定的。举例：JDK中编写了一个java.util.List，这个List中存放什么呢？这个问题很容易回答，因为JDK的开发人员在编写JDK的代码的时候，肯定要面临一个问题：除了JDK中自带的那些类型，开发者还能自定义类型，怎样将开发者后面使用JDK的时候自定义的类型也能放到List中去呢？这个时候如果你将一个List中可以保存的数据的类型固定死，那明显就不成了。一个List中，既存放了学生、又存放了食品、还存放了数字，那岂不是乱套了，就算不乱，代码处理这个List的时候得多复杂？

所以，开发JDK的人，就在编写java.util.List的代码的时候，没有明确这个List中存放什么，而是让开发者在使用java.util.List的时候去指定，这样就实现了：定义接口或类时，该接口或类所使用的其他类型未知，使用该接口或类时，能够明确该接口或类所使用的其他类型是什么。具体在Java语法上，使用一对尖括号和中间一个字母来表示，类似于<T>，当然了，这个也分多种情况： - 定义一个接口，它的功能是对某个类实现特定功能（如序列化、转换等等），什么类呢？未知，使用该接口时才确定，那么在定义这个接口时用<T>表示，T即Type之意 - 定义一个接口或类，引用了另外一个类型，什么类型呢？未知，使用该接口或类时才确定，那么在定义这个接口时用<T>表示，T即Type之意 - 定义一个容器，这个容器中存放什么类型的数据呢？未知，使用该容器时才能确定，那么在定义这个容器时用<E>表示，E即Element之意 - 定义一个键值对的映射关系表（类似于汉语字典中的一个汉字对应一篇解释文章），键是什么类型呢？未知，使用它时才能确定，所以定义时用<K>表示，K即Key之意，同例，值用<V>表示，取Value之意

如果你理解了上述这些东西，就说明你知道什么是泛型了。

Java中最常见的java.util.List的定义是这样的：

public interface List<E> extends Collection<E> {
    // 内容省略
}

这是指列表List或容器Collection中存放什么东西未知，取Element之意，简写为E。

JDK8中的Optional的定义是这样的：

public final class Optional<T> {
    // 具体内容省略
}

Java中最常见的Map（键、值对映射关系表）是这样定义的：

public interface Map<K, V> {
    // 具体内容省略
}

这个稍有特殊，它是指一个被定义了泛型的Java类或接口，其实可以支持多个泛型声明，即：这个接口或类在编写时，引用了多个其他类型，被引用的多个其他类型都是在代码运行时动态决定的。当然了，通常最多也就是2个，太多了就会复杂代码的复杂度，反倒有害。

怎么使用泛型

知道了什么是泛型，怎么使用泛型就很简单了，看下面的示例：

List<Integer> numbers = new ArrayList<>();

这段代码的完整形式是这样的：

List<Integer> numbers = new ArrayList<Integer>();

很明显，定义ArrayList的时候，指明它里面存放的是Integer类型，声明List变量的时候，指明它里面存放的是Integer类型。这样一来，就只能在这个numbers中放整数而不能放其他内容。这对于代码约束和规范，防止数据意外错乱是非常有帮助的。

我们自己定义泛型的时候，有可能有一种特殊情况，例如：类A类和类B都是预置好的，现在有个我自定义的MyList，它和List一样是个容器，里面我想让它既能放A又能放B（当然，它们的子类也可以放进去），这个要怎么弄呢？其实也很简单，我们只需要给类A和类B抽象一下，搞一个它们的父类或接口，让它俩去继承这个父类或接口，就可以了，比如搞一个父类：

class Parent {}
class A extends Parent {}
class B extends Parent {}

此时，我定义我的MyList，让它支持泛型（定义时不指定类型，使用时指定类型），如下所示：

class MyList<T extends Parent> {}

接口也是一样的，就不赘述了。

类型擦除

Python语言由荷兰数学和计算机科学研究学会的吉多·范罗苏姆于1990年代初设计。 Python语言提供了高效的高级数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的编程语言，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。

本栏目的详细内容正在建设中…

泛型的擦除，你可以这样简单的理解：编写代码时，指定用某某类型，但是运行时其实它并不存在（在动态运行中的代码是获取不到当初编写代码时写的那个泛型的），因为在编译时把它换了，比如换成了Object（以List为例，反正你放进去的时候是Object、取出来的时候还是Object，它该是数字始终是数字，该是字符串始终是字符串，不会出现无法识别或解析不了的情况）。可问题是：编写代码时写了泛型，编译时又擦除了泛型，为什么要这么做呢？其实原因也很简单： - 代码是写给人看的，却是写给机器执行的，想要让人容易看懂，快速看懂，明确指定List中放的到底是什么类型，是很有必要的 - 有利于代码重用，我总不能有N个数据类型，就定义N种List，现在有了泛型，我只要定义一种泛型List就可以了，代码不会很冗余，真有修改，就改一处，不必把所谓的所有类型的List都改一遍，成本也低很多 至于运行嘛，当然是毫无影响的，反正都是堆上的对象。

最后一个问题：将所有写的泛型都擦除为java.lang.Object明显有点离谱，我们遵循下面这些约定： - 若泛型类型没有指定具体类型，用Object作为原始类型，如：List numbers = new ArrayList()，我们不推荐这种写法 - 若有限定类型< T exnteds XClass>，使用XClass作为原始类型，如：class Score extends <T extends Person>，类型擦除之后是Person - 若有多个限定<T exnteds XClass1 & XClass2>，使用第一个边界类型XClass1作为原始类型

列表（List）

列表，就是“一组”相同的东西放在一起，就组成一个列表，然后“放在一起”的方式，又分为两种：

• 很紧凑的放在一起，这就是数组，很显然，这种结构从中找到某个东西很快，从头到尾找一遍，很容易就找到了
• 很松散的放在一起，这就是链表，很明显，前后不紧挨着，那么要处理三种情况：
  • 前面的人记住后面的人的位置，这样才能从前面的人找到后面的人，然后继续往后找，不然就断线了
  • 后面的人记住前面的人的位置，这样才能从后往前找，不然就断线了
  • 前面的人以后面的人的位置，后面的人也记住前面的人的位置，这是双向链表，从前往后找可以，从后往前找也可以

注意：是相同的东西才可以放在一起，这和其他弱类型的语言（如JavaScript）不同。

关于数组和链表，网上有一张图，我们借用过来看一下它们的区别：

数组的使用

定义数组：

int[] numbers = new int[3];

定义并且初始化：

int[] numbers = new int[]{1, 2, 3, 4};
String[] names = new String[]{"jack", "john", "james"}

定义并且初始化的时候，可以不必指定数组的长度，编译器会自动处理。

只取数组元素的方式遍历数组：

int[] numbers = new int[]{1, 2, 3, 4};
for (int number : numbers) {
    System.out.println(number);
}

取数组的同时取数组元素的下标位置（下标位置从0开始）：

int[] numbers = new int[]{1, 2, 3, 4};
for (int i = 0; i < numbers.length; i++>) {
    System.out.println(i + ":" + number);
}

运行上述代码可以得到，数组int[]{1, 2, 3, 4}的4个元素的下标分别是0、1、2、3，数组的长度是4

从数组中找到某个元素是否存在，通常代码这样写：

public int indexOf(int[] numbers, int value) {
    for (int i = 0; i < numbers.length; i++>) {
        if (numbers[i] == value) {
            return i;
        }
    }
    return -1;
}

逻辑很简单：如果在numbers中找到了value，就返回value的下标，如果没找到，就返回-1。但是请注意，下面的代码是有问题的：

public int indexOf(String[] numbers, String value) {
    for (int i = 0; i < numbers.length; i++>) {
        if (numbers[i].equals(value)) {
            return i;
        }
    }
    return -1;
}

系统内置列表方法

Java的JDK中内置列表我们最常用的是两个：ArrayList和LinkedList，前者本质上就是一个数组，后者就是一个链表。只不过它们还提供了很多方法供我们很方便的使用，比如添加元素、查找元素、删除元素等等。它们有一些常见的方法，简单列举一下：

• size() 获得元素数量
• isEmpty() 判断是否为空列表，其实就是大小为0，即：size() == 0
• contains() 是否包含某个元素，判断时会调用元素的equals方法
• toArray() 转换为数组
• toArray(T[]) 转换为指定类型的数组
• remove(E) 删除一个元素，判断依据依然是调用元素的equals方法
• remove(int) 删除指定索引位的元素
• containsAll() 是否包含一个子列表
• addAll() 添加了个子列表
• clear() 清空
• retainAll() 取差集
• sort() 排序，此时元素必须实现Comparator接口
• get(int) 获得指定索引位的元素（索引位从0开始）
• set(int, E) 更新指定索引位的元素
• subList(int, int) 切分子列表

上面这些方法中提到的E，以及你去看List的源码的时候，还有尖括号中的T，都是泛型，所谓泛型，就是指代码在编写的时候不指定类型，在调用的时候、初始化的时候才指定类型。

列表使用注意事项

JDK中的ArrayList和LinkedList，有几个知识要点，我们在这里罗列一下：

• 不能并发删除，这会导致元素序列错乱，它们不是线程安全的
• 如果在操作元素的时候会有删除操作，最好使用迭代器Interator，然后做判断，既不要使用传统的for…i循环，也不要使用增强for循环，代码示例：

// 准备数据
List<Integer> numbers = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
// 遍历删除
Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    Integer number = iterator.next();
    if (number.equals(1)) {
        // 使用迭代器的删除方法删除
        iterator.remove();
    }
}

• 调用Arrays.asList()生产的List不可以使用add，remove，这是由Arrays.asList() 返回的市Arrays的内部类ArrayList， 而不是java.util.ArrayList。
• java.util.List中的subList方法，是返回list的一部分的视图，注意，是视图，不是一个全新的子列表，所以，这个视图的存在，是依托于原来的List而存在的，查看源代码即可知道，subList返回的是通过java.util.ArrayList.SubList#SubList这个内部类生成的，它里面还有parent指向上一层外部类。因此修改这个所谓的子列表，会影响原列表，反之，如果父类被修改了，那内部类的子列表依托于谁呢？它就无法解释了，所以，就会抛出一个ConcurrentModificationException。
• ArrayList存在一个扩容问题，ArrayList初始容量为0（创建时未指定大小），在第一次添加元素时，会进行扩容，此时容量为默认的10，之后每当向集中中添加元素达到上限时，进行扩容，扩容为原来的1.5倍。注意：这里指的是JDK7的情况，JDK6及之前，创建ArrayList对象实例时，初始容量直接是10，不存在第一次添加元素时扩容到10的操作。

映射（Map）

映射其实是一种数据的逻辑结构，它和存储结构无关，逻辑上，数据和数据之间存在一一对应关系，就会形成键值对，比如一个身份证号对应一个手机号，相信看到这里，有人会说不对，一个人可以办多张手机卡的，确实如此，但是我们在这里讨论的核心逻辑，是以一个确定的要素去对应另外一个确定的要素。

HashMap简介

Java中映射类型（键-值对）有好几种，最常见的、用的最多的，就是HashMap，本文为初学者计，暂时只探讨HashMap，这些知识也可供有经验的程序员同行们参考。

HashMap里面存放的是键值对，一个键对应一个值，好比书本的目录和文章、字典的索引和字义解释文章等。所以称之为映射。

HashMap使用

HashMap的使用非常简单：

HashMap初始化

Map<String, Integer> m1 = new HashMap<>();
Map<String, Integer> m2 = new HashMap<>(32);
Map<String, Integer> m3 = new HashMap<>(32, 0.5);

m1的定义，是初始化一个HashMap，一切依照默认值，初始容量大小是16，负载因子是0.75 m2的定义，是初始化一个HashMap，指定初始容量大小是32，负载因子是默认的0.75 m3的定义，是初始化一个HashMap，指定初始容量大小是16，负载因子是0.5

负载因子是扩容的时候用的（数据多，存不下了，就要扩大容量，称为扩容）。具体后面有讲解。

HashMap存取数据

m1.put("s1", 1);
m2.put("s2", 2);
m1.get("s1");
m1.getOrDefault("s1", 0);

• 存入数据时，如果原来这个Key下没有值，就返回null，如果原来这个key下有值，就返回前一个值
• 取得数据时，如果key下没有值，返回null
• 可以将一个Map直接整个放入另外一个Map，示例代码：m1.putAll(m2)，当然了，两个Map的Key和Value要一样，否则会报错的
• 可以将一个值放入Map的时候设置如果有值，就不放入，没有才放入，调用m1.putVal(key.hash(), v, true, true)即可，第三个参数如果传true，就能实现有值不操作，无值就放入，如果第三个值传false，无论是否有值了，都放入（这样会更新以前已经存在的值）
• 取得值时，可以指定不存在的时候的默认值（JDK8中才有），示例代码：m1.getOrDefault("s1", 0)

HashMap遍历

遍历HashMap有好几种方法方法，假设我们有这样的HashMap定义：

Map<Integer, Integer> map = new HashMap<Integer, Integer>();

同时需要值和值时，通常这样操作：

for(Map.Entry<Integer, Integer> entry : map.entrySet()){
	System.out.println("key: " + entry.getKey() + ", value: " + entry.getValue())
}

单纯的使用Key：

for (Integer key : map.keySet()) {
	System.out.println("Key: " + key);
}

单纯的使用Value：

for (Integer value : map.values()) {
	System.out.println("Value: " + value);
}

使用迭代器：

Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
	Map.Entry<Integer, Integer> entry = entries.next();
	System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

HashMap原理

HashMap的原理是非常重要的，原因如下：

• 这个数据结构太常用了，用的实在太多了，所以非常熟悉它是很有必要的
• 这是各科技公司、互联网大厂面试必问题

源代码剖析

Map是一个接口，HashMap是一个类，它实现了Map这个接口。

在cnblogs上，大神张铁牛发布的博文中，有一张图说明了JDK8中HashMap的结构（JDK7及以前的有所不同，这里只讲JDK8的），借来一用：

简单地说，HashMap内部其实是一个数组，每个数组元素称为一个Hash桶，这个所谓的Hash桶，默认情况下它是个列表，当有数据存进来的时候，根据数据计算一个它的Hash值（就是数学上的散列函数），然后再经过一些处理，就能计算出一个数组下标，此时就知道该数据要往哪个数组元素所在位置下的列表里放了（也可称这个过程中为散列到指定的哈希桶中去），要想弄清楚上图中HashMap的这些特性，我们先看它的源代码java.util.HashMap中的一些关键信息：

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {

    private static final long serialVersionUID = 362498820763181265L;
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    static final int MAXIMUM_CAPACITY = 1 << 30;
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;
    transient Node<K,V>[] table;
    transient Set<Map.Entry<K,V>> entrySet;
    transient int size;
    transient int modCount;
    int threshold;
    final float loadFactor;
}