Java

Java是由Sun Microsystems公司于1995年5月23日发布的一种面向对象的编程语言。Java是在C++基础上改进而来，它继承了C++的优点，同时摒弃了C++中指针等难以理解的概念。因此Java相对简单且功能强大。除此之外，它还具备可移植、高性能、分布式、动态、健壮与安全等特点。

1991年，美国Sun Microsystem公司成立了一个由James Gosling，Patrick Naughton与Mike Sheridan等人组成的名为“Green”的研发小组，其目的是为家用电子产品开发一个分布式代码系统，以实现对家用电器的集成控制。在开发过程中，Gosling发现C/C++语言无法满足项目需求。于是Gosling于1991年6月开始开发一种新的编程语言，并命名为Oak，这就是Java的前身。1994年，互联网火速发展，Gosling对Oak进行了一定的改造，决定用其开发一个新的web浏览器。Naughton与Jonathan Payne负责该项目，并于1994年秋天完成了WebRunner的开发。1995年1月，因发现Oak已被其他公司注册，Oak改名为Java，Java 是印度尼西亚的一个重要的盛产咖啡的岛屿，中文名叫爪哇，开发人员将语言起名为Java，其寓意是为世人端上一杯热咖啡。WebRunner改名为HotJava。1995年5月23日，Sun Microsystems公司正式发布了Java与HotJava。 美国X杂志《PCMagazine》将Java语言评为1995年十大X科技产品。

1996年1月，Java 1.0发布，1.0版本包括Java虚拟机、网页应用小程序及可以嵌套在网页中运行的用户界面组件，开发人员通过用户界面组件可以开发窗口应用程序。同年，Microsoft、 Netscape等公司的Web浏览器宣布支持Applet，而IBM、Apple、 DEC、Adobe.Silicon Graphics、HP、Oracle和Microsoft等公司相继XJava技术许可证，从此Java成为应用广泛的程序设计语言。1997年11月，国际标准化组织式批准了Sun Microsystems等公司提出的Java 标准。Java标准化促进了它的进一步发展，也标志着Java语言走向成熟。 19X12月，Java 1.2发布，该版本在图形化用户界面、数据库互联以及其它许多方面做了改进，如加入了strictfp关键字，在class文件格式中加入相应的访问标志，引人了类装载器的双亲委派模型以及Javalang.Class类和javalang.ClassLoader类的几个新方法，并澄清修正了Java虚拟机规范。 1999年，Java平台被分为J2ME、J2SE和J2EE，这三个平台分别定位于嵌入式应用、桌面应用和企业级应用，使Java技术获得了广泛的应用。 2002年2月，Java 1.4发布，并因为CompaqFujitsu、SASSymbian、IBM等公司的参与，使JDK 1.4迅速发展。2004年9月30日，Java 5发布，这个版本的Java有了很大的改进，它加入了泛型、枚举、注解等新特性，使得Java编程更加方便。为了X这次重大的革新，Sun公司不再延续之前使用的1.x版本号，而是直接将版本改为了5.0。2005年，Sun公司取消Java 2名称，Java三大平台分别被更名为Java ME、Java SE、Java EE。 2006年11月，Sun公司正式宣布Java平台开源，全世界的所有程序员都可以免费下载并修改其源代码。

2009年4月，Sun公司以74亿美元被Oracle公司X，作为Sun公司的核心资产之一的Java也归属于Oracle公司。2011年7月，Java 7发布，该版本为Oracle公司发布的X个Java版本，引入了菱形语法、多异常捕获等新特性；2014年3月，Java 8发布，该版本是继JDK 5后改革最大的一个版本，添加了很多新特性，如Lambda表达式、Stream、API、新版日期时间API等。2017年，Java 9发布，同时，Oracle公司颁布了“6个月版本升级计划”，即每隔6个月发布一个新版本。

2023年3月21日，Java已更新到Java 20。Oracle为开发人员、最终用户和企业提供JDK 20，但JDK 20不是长期支持版本。 2023年8月，Java位列TIOBE编程社区指数中最受欢迎的编程语言第四名。 目前，Java是企业和开发人员的X开发平台，全球有数百万开发人员运行超过60亿台Java虚拟机。

Sun公司在1995年发布的Java白皮书表示：Java是一种简单的、面向对象的、分布式的 、健壮的、安全的、X结构中立的 、可移植的、解释型的、高性能的、多线程的和动态的语言。

简单性：Java通过提供最基本的方法来完成指定的任务，只需理解一些基本的概念，就可以用它编写出适合于各种情况的应用程序。Java 略去了运算符重载、多重继承等模糊的概念，并且通过实现自动无用信息回收，简化了程序设计者的内存管理工作。另外，Java也适合在小型机上运行，它的基本解释器及类的支持只有40KB左右，加上标准类库和线程的支持也只有215KB左右。

面向对象的：Java语言是一种纯粹的面向对象的语言。Java语言的设计集中于对象及其接口，它提供了简单的类机制以及动态的接口模型。对象中封装了它的状态变量以及相应的方法，实现了模块化和信息隐藏；而类则提供了一类对象的原型，并且通过继承机制，子类可以使用父类所提供的方法，实现了代码的复用。

分布式：Java是分布式语言。JDK中包含基于TCP/IP协议的类库，可以轻松实现分布式应用系统，进行分布式计算。Java程序可以凭借URL打开并访问网络中的对象，其访问方式与访问本地文件系统几乎完全相同。

健壮性：Java在编译和运行的过程中会进行比较严格的检查，以减少错误的发生。Java不提供指针，从而杜绝开发者对指针的误操作，如内存分配错误、内存泄漏等造成系统崩溃的可能性。在内存管理方面，C/C++等采用手动分配和释放，经常导致内存泄漏，进而导致系统崩溃。而Java采用自动的内存X回收机制，程序员不需要管理内存，这样可以减少内存错误的发生，提高程序的健壮性。

安全性：Java的安全性体现在两个层面，即Java的底层运行机制和Java提供的安全类API。在底层运行机制方面：Java没有提供指针机制，避免了指针机制可能带来的各类安全问题；Java通过类型安全设计和自动的X回收机制来提高程序代码的健壮性；Java提供了安全的类加载和验证机制，确保只执行合法的Java代码。在API层面，Java提供了大量与安全有关的应用程序接口、工具，以及常用安全算法机制和协议的实现。

X结构中立与可移植：Java程序在Java平台上被编译为X结构中立的字节码格式 ，可以方便地被移植到网络上的不同机器。Java的类库中也实现了与不同平台的接口，使这些类库可以移植。另外，Java编译器是由Java语言实现的，Java运行时系统由标准C实现，这使得Java系统本身也具有可移植性。

解释型与高性能：程序运行时，Java解释器直接对Java字节码进行解释执行。字节码本身携带了许多编译时信息使得连接过程更加简单。和其他解释执行的语言如BASIC、TCL不同，Java 字节码的设计使之能直接转换成对应于特定CPU的机器码，从而得到较高的性能。

多线程：Java是多线程语言，能处理不同任务。Java的lang包提供一个Thread类，支持开始线程、运行线程、停止线程和检查线程状态的方法。

动态：Java程序在运行过程中可以动态地加载各种类库，即使更新类库也不必重新编译使用这个类库的应用程序。这个动态特点使其非常适合在网络环境下运行，并且有利于软件的开发。

自1995年5月23日发布以来，Java已更新发布多个版本。

Java版本

发布版本	时间	更新
Java 1.0	1996年1月	体现语言本身的特性，类与接口的数量有211个
Java 1.1	1997年2月	在class文件格式中增加了两个属性，用来支持内部类；增加了一个属性用来支持@deprecatedjavadoc标签；扩展了CIassLoader类的API，类与接口的数量增加到477个
Java 1.2	19X12月	加入了strictfp关键字；在class文件格式中加入相应的访问标志；引人了类装载器的双亲委派模型以及Javalang.Class类和javalang.ClassLoader类的几个新方法，类与接口的数量增加到1524个
Java 1.3	2000年5月	类与接口的数量增加到1840个
Java 1.4	2002年2月	增加断言机制，类与接口的数量增加到2723个
Java 5	2004年9月	增加泛类型，for cach循环、可变参数、自动装箱、元数据、枚举、静态导入等特性，类与接口的数量增加到3279个
Java 6	2006年12月	类与接口的数量增加到3793个
Java 7	2011年7月	增加基于字符串的switch、变形操作符、二进制字面量等特性，并改进异常处理，接口数量增加到4024个
Java 8	2014年3月	可以为接口的方法添加方法体（称为默认方法），这些方法会被隐式地添加到实现这个接口的类中；提供isAlive()与destroyForeibly()两个控制进程的方法； 引入日期时间应用程序接口（date time API）
Java 9	2017年9月	引入模块系统；提供Javadoc，支持在 API文档中进行搜索，输出兼容HTMLS标准；在List、Set、Map接口中，静态工厂方法可以创建这些集合的不可变实例；改进 API 来控制和管理操作系统进程；改进 Optiomal 类；内置一个轻量级的JSON API
Java 10	2018年3月	增加局部变量的类型推断特性；将 JDK 的多个代码仓库合并到一个储存库中；通过引入一个干净的X收集器（GC）接口，改善不同X收集器的源码隔离性；向G1引入并行Full GC；拓展类数据共享（“CDS”）功能，以允许应用类放置在共享存档中；允许停止单个线程，而不是只能启用或停止所有线程；移除Native-Header Generation Tool (javah)；扩展额外的 Unicode 语言标签；允许 HotSpot 虚拟机在备用内存设备上分配 Java 对象堆
Java 11	2018年9月	引入NestMembers属性，用于标识其他已知的静态nest成员；引入nest成员部包含的NestHost属性，用于标识出它的nest宿主类;支持 TLS 1.3 协议
Java 12	2019年3月	switch可以作为语句或表达式；G1 可及时归还不使用的内存；移除多余的ARM64 实现；改进G1的可中断 Mixed GC；增加JVM常量API
Java 13	2019年9月	采用一种不同的方法来表示字符串而不转义换行字符和引号
Java 14	20X3月	增加 instanceof 的模式匹配、打包工具 （Incubator）、G1 的非统一内存访问（NUMA）分配优化、飞行记录器 （JFR）事件流；移除 Pack200 Tools和 API，使用外部存器 API；引入友好的空指针异常处理；弃用Solaris和SPARC端口
Java 15	20X9月	删除Nashom JavaScript引擎；重新实现Legacy DatagramSocket API；重新实现DatagramSocket APl；移除Solaris和 SPARC端口
Java 16	20X3月	提升Java在CPU向量计算中的性能，提升了Java在人工智能（AI） 领域的能力；允许JDK中的C++源代码中使用C++ 14的特性，提供UNIX套接字对ServerSocketChannel和SocketChannel的支持；改进Hospot对类元数据的处理；占用空间减少，可以更快地将未使用的内存回收到操作系统中
Java 17	20X9月	恢复浮点语义；为伪随机数发生器（PRNG）提供新的接口类型；增加macOS AArch64端口；删除Applet API；删除远程方法调用（RMI）激活机制；强封装JDK内部
Java 18	20X3月	将UTF-8设定为标准Java API的预设字元集；增加用于启动仅提供静态档案的最小网络服务器；在java.lang.invoke方法处理之上重新实行java.lang.reflect.Method、Constructor和Field；为JavaDoc的标准Doclet采用@snippet标记，以简化在API文件中包含示例原始码
Java 19	20X9月	增加记录样式与Switch模式比对；增强可与非Java代码（外部函数与內存API）交互运作的程序库功能；增加虚拟线程与结构化并行，减少在Java中编写和维护高传输量并行应用程序的工作量
Java 20	2023年3月	在G1中添加GarbageCollectorMXBean作为备注和清理暂停时间；在x86_64和aarch64平台上提供ChaCha20本质；支持Unicode 15.0；改进G1并发优化线程；支持CLDR版本42；新增JFR事件：jdk.InitialSecurityProperty、jdk.SecurityProviderService；改进预览API页面；新增“jmod--compress”命令行选项；将时区数据更新到2022c；JavaDoc标题中自动生成ID

标识符就是用于给程序中变量、类、方法命名的字符序列，由字母、数字、下划线、美元符组成，且必须以字母、下划线或美元符开头。Java语言的字符使用Unicode编码标准，因此Java的标识符可以使用Unicode所能表示的多种语言的字符。Java标识符的字母符号区分大小写，所以 count、Count和COUNT表示不同的标识符。此外，标识符中不可以包含空格，不能使用Java的关键字，标识符的长度没有限制。

Java语言中有固定含义的标识符称作关键字，共有48个，其中enum是Java 5.0新增的关键字，用于定义一个枚举。

Java关键字

abstract	boolean	break	byte	case	catch
char	class	continue	default	do	double
else	enum	extends	false	final	finally
float	for	if	implements	import	instanceof
int	interface	long	native	new	null
package	private	protected	public	return	short
static	super	switch	synchronized	this	throw
throws	transient	true	try	void	while

除了上面的48个关键字之外，Java还包含goto和const两个保留字与三个特殊的直接量true、false和null，Java 语言的标识符也不能使用这两个保留字和三个特殊的直接量。

变量是一个保存数据的内存区域的名字。变量在使用时必须先定义 （或称声明），然后才能用赋值语句（或其他形式）来为其赋值。变量的命名必须标识符的命名规定。变量定义是指示编译器为特定数据类型的数值保存在内存中分配适当的内存空间。变量的声明格式为：<数据类型名><变量名表>。

变量的使用范围称作变量的作用域，定义该变量的程序块，每个变量只在自己的使用范围内有效。

在整个程序运行期间保持不变的变量称作常量。常量也是一种标识符，所以定义常量时也要符合标识符的规定。 定义常量的方法是在定义变量的语句最前面加上关键字final。常量定义是指示编译器为特定数据类型的数值保存在内存中分配适当的内存空间。与变量不同的是，常量只允许在定义时给出其数值，并不允许在随后的程序中改变其数值。常量名通常为全大写字母。

Java语言X定义了8种基本数据类型，其中4种为整型数，2种为浮点型数，1 种为字符型数，1种为布尔型数。

整型数包括零和有限范围内的正整数和负整数，不同整型数的数据位不同，所以相应的正整数和负整数的范围也不同。

浮点型数由整数部分和小数部分组成。浮点型数可以表示精度很高的或带有小数部分的数值。

在Java语言中，一个Unicode标准下的编码称作一个字符。字符型（char）用来表示字符型变量和字符型字面值。字符型字面值用一对单引号括起来，如’a’、’A’、’#’等都是字符型字面值。不能直接显示的控制字符字面值或字符串中特殊符号表示，可以使用转义字符的表示方法。

布尔型（boolean）也称逻辑型，用于表示逻辑上的“真”或“假”。在Java语言中，boolean类型的数值只能是true或false，不能用0或者非0来代表。其他基本数据类型的值也不能转换成boolean类型。

整型与浮点型

-	类型	数据位
整型数	字节型 byte	8 bits
	短整型 short	16 bits
	整型 int	32 bits
	长整型 long	64 bits
浮点型	单精度浮点 float	32 bits
	双精度浮点 double	64 bits

赋值语句的语法形式是：

Java

1

<变量> = <表达式>

其中，等号（称作赋值号）是赋值语句的标识；<表达式>可以是一个常量，或另一个已赋过值的变量，或是由运算符组成的一个表达式。当一个变量被赋值语句重新赋值时，该变量原先的取值就没有了。

Java语言是一种强类型语言，即对数据类型的匹配要求十分严格。如果一个表达式的数据类型出现不一致等问题，则编译器给出类型不一致的出错信息。

类型相同是指赋值号左端的数据类型和赋值号右端的数据类型完全一致，此种情况可以正确赋值。

Java

1

2

int Value1 =100;
long Value2 = 100L; 

类型兼容是指赋值号左端的数据类型的位数长比赋值号右端的长。此时系统会自动将赋值号右端的数据类型的位数长转化成和赋值号左端一样的长度。

Java

1

2

long Value1 = 100; //100 是 int 类型，将自动转化为 100L
double Value1= 3.141F; //3.141F 是 float 类型，将自动转化为3.141 

若赋值号右端的数据类型的位数长比赋值号左端的长，则类型不兼容。在编译时会产生“可能存在精度损失”的编译错误。

当出现类型不兼容错误时，有两种解决方法：重新定义赋值号左端变量的数据类型，使之变成满足要求的较长的数据类型；用强制类型转换方法把赋值号右端的数据类型转换成和赋值号左端相同的数据类型。

Java

1

2

3

4

5

//强制类型转换
//可能丢失数据或损失数据的精度
int i;
long k = 100L;
i = (int) k; //把变量k中的数值强制转换成int类型后赋给变量i 

算术运算符：Java算术运算符分为一元运算符和二元运算符，一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。

比较运算符：用于程序中的变量和变量之间、变量和常量之间以及其他类型的信息之间的比较。

位运算符：位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。

类型	运算符	描述
一元算术运算符	负（-）	会产生其操作数的负值
	正（+）	会原样输出其操作数
	自加（++）	放在操作数之前，则操作数先加1，然X行其他相应的操作（主要是赋值操作）；放在操作数之后，先进行其他相应的操作，然后再将操作数值加1
	自减（− −）	放在操作数之前，则操作数先减1，然X行其他相应的操作（主要是赋值操作）；放在操作数之后，先进行其他相应的操作，然后再将操作数值减1
二元算术运算符	减（-）	输出操作数的差
	加（+）	输出操作数的和
	乘（ * ）	输出操作数的乘积
	除（/）	输出操作数的商。两操作数均为整数，结果为整数；其中至少存在一个浮点数，结果为浮点数
	取余（%）	输出X个操作数除以第二个参数的余数，运算结果的符号与左操作数相同
比较运算符	等于（==）	比较操作数数值，若X个操作数等于第二个操作数，结果为True，否则为False
	不等于（!=）	比较操作数数值，若X个操作数不等于第二个操作数，结果为True，否则为False
	大于（>）	比较操作数数值，若X个操作数大于第二个操作数，结果为True，否则为False
	大于等于（>=）	比较操作数数值，若X个操作数大于等于第二个操作数，结果为True，否则为False
	小于（<)	比较操作数数值，若X个操作数小于第二个操作数，结果为True，否则为False
	小于等于（<=）	比较操作数数值，若X个操作数小于等于第二个操作数，结果为True，否则为False
位运算符	位与（&）	把两个操作数在计算机底层的二进制码按位求与
	位或（|）	把两个操作数在计算机底层的二进制码按位求或
	位非（~）	需要一个操作数，这个运算符将把操作数在计算机底层的二进制码按位取反
	位异或（^）	把两个操作数在计算机底层的二进制码按位求异或
	右移（>>）	把X个操作数的二进制码右移指定位数后，左边空出来的位以原来的符号位来填充。即如果X个操作数原来是正数，则左边补0；如果X个操作数是负数，则左边补1
	左移（<<）	将运算数的二进制码整体左移指定位数，右边空出来的位以0来填充
	无符号右移（>>>）	把X个操作数的二进制码右移指定位数后，左边空出来的位以0来填充
	左移运算符（<<）	1<<2：会将X个参数左移第二个参数所指定的比特位数，结果为4
	右移运算符（>>）	1>>2：会将X个参数右移第二个参数所指定的比特位数，结果为0

逻辑运算符：要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。逻辑运算符有： 逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑或（|）。 两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和 | 运算是把逻辑表达式全部计算完，而&&和 || 运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。

真值表

A	B	A&&B	A||B	!A	A^B	A&B	A|B
false	false	false	false	true	false	false	false
true	false	false	true	false	true	false	true
false	true	false	true	true	true	false	true
true	true	true	true	false	false	true	true

扩展后的赋值运算符：赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而简化一些常用表达式的书写。

扩展后的赋值运算符

运算符	用法	等价于	说明
+=	s+=i	s=s+i	s，i 是数值型
−=	s−=i	s=s−i	s，i 是数值型
*=	s*=i	s=s*i	s，i 是数值型
/=	s/=i	s=s/I	s，i 是数值型
%=	s%=i	s=s%i	s，i 是数值型
&=	a&=b	a=a&b	a，b 是逻辑型或整型
|=	a | =b	a=a | b	a，b 是逻辑型或整型
^=	a^=b	a=a^b	a, b 是逻辑型或整型
<<=	s<<=i	s=s<<=i	s，i 是整型
>>=	s>>=i	s=s>>i	s, i 是整型
>>>=	s>>>=i	s=s>>>i	s, i 是整型

方括号[ ]与圆括号()：方括号是数组运算符，方括号中的数值是数组的下标，整个表达式就代表数组中该 下标所在位置的元素值。 圆括号运算符用于改变表达式中运算符的优先级。

字符串加（+）运算符：当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器自动将数值转换为字符串。

条件运算符：语法形式为〈表达式 1〉?〈表达式 2〉:〈表达式 3〉。条件运算符的运算方法是先计算〈表达式 1〉的值，当〈表达式 1〉的值为 true 时，则将〈表达式 2〉的值作为整个表达式的值；当〈表达式 1〉的值为 false 时，则将〈表达式 3〉 的值作为整个表达式的值。

强制类型转换符：能将一个表达式的类型强制转换为某一指定数据类型，其语法形式为(〈类型〉)〈表达式〉

对象运算符instanceof ：用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回 true，否则返回 false。

点运算符（·）：功能有两个：引用类中成员；指示包的层次等级。

按优先级从高到低的次序列出Java语言中的所有运算符。

运算符优先级

运算符	运算次序
. [ ] ( ) ; ,	-
++ −− += ～ ! +（一元）−（一元）	从右向左
* / %	从左向右
+（二元） −（二元）	从左向右
< > <= >= instanceof	从左向右
== !=	从左向右
<< >> >>>	从左向右
&	从左向右
^	从左向右
|	从左向右
&&	从左向右
||	从左向右
?：	从右向左
= *= /= %= += －= <<= >>= >>>= &= ^= |=	从右向左

用运算符和圆括号把运算对象连接起来的、符合Java语言语法规则的式子称作表达式。 表达式按照运算符的优先级逐个进行计算，最后求得整个表达式的值。由于运算对象是有数据类型的，所以最终得到的计算结果也是有数据类型的，表达式结果的数据类型不一定和运算对象相同，它还取决于表达式的运算符。

Java表达式既可以单独组成语句，也可出现在循环语句、条件语句的条件部分，还可以出现在函数的实际参数调用等场合。赋值语句也是一个表达式，其运算方法是先计算出赋值运算符右边的表达式的值（因赋值运算符的优先级最低），然后把该值赋给赋值运算符左边的变量（因赋值运算符的结合性是先右后左的）。

在Java程序中，一个以分号结束的符号串称为一条语句。流程控制语句用来控制程序的执行流程，有条件选择语句，循环语句和转移语句三种。 任何程序的结构都是由顺序结构、分支结构和循环结构三种基本结构组成的。在顺序结构的程序或程序段中，程序是按语句次序顺序执行的。在分支结构或循环结构的程序或程序段中，程序按分支结构语句或循环结构语句所规定的执行流程来执行。

分支结构是指程序按照当前的分支条件控制程序流程的执行。Java语言有两种分支结构的语句：if语句和switch语句。

基本的if语句的语法形式为：

Java

1

2

3

4

if （〈逻辑表达式〉） {
〈语句组 1〉； 
}[else {
〈语句组 2〉；}]

if 语句的含义是：当〈逻辑表达式〉的值为true时，执行 if 后面的〈语句组 1〉；当〈逻辑表达式〉的值为false时， 执行else后面的〈语句组 2〉。当执行的语句组中的语句多于一条时，语句组必须用一对花括 号“{}”括起来。在Java语言的语法中，一对方括号“[ ]”括起来的部分，表示该部分（除数组定义外）是任选的。因此，else语句是任选的，当没有else语句时，若〈逻辑表达式〉 的值为false，就执行分支语句外的语句。if语句的逻辑表达式中的条件可能多于一个，这称为复合条件，复合条件需要用逻辑运算符。如果if语句中又包括另一个if语句，则称为if语句嵌套。 Java语言规定：else总是与最近的一个if语句匹配。

switch语句的语法形式为：

Java

1

2

3

4

5

6

7

8

switch（〈表达式〉）{
 case〈常量 1〉：〈语句组 1〉;
 [break；]
 case〈常量 2〉：〈语句组 2〉;
 [break；]
 ……；
 [default：〈语句组〉]
} 

switch语句中〈表达式〉的值必须是整型或字符型常量。switch语句首先计算表达式的值，如果表达式的值和某个case后面的变量值相同，则执行该case语句后的若干个语句直到遇到break语句为止，如果该case语中没有break语句，将继续执行后面case中的若干个语句，直到遇到break语句为止。若没有一个常量的值与表达式的值相同，则执行default后面的语句。default语句为可选的，如果它不存在，且switch语句中表达式的值不与任何case的常量值相同，switch则不做任何处理。

循环结构是指程序按照当前的循环条件控制程序流程的执行。Java 语言有三种循环结构的语句：for语句、while语句和do-while语句。这三种循环语句虽然控制循环的方式不同， 但实现循环的功能相同。

for语句的语法形式为：

Java

1

2

for ([〈表达式 1〉]；[〈表达式 2〉]；[〈表达式 3〉])
〈循环体〉；

for语句的语义是：首先计算〈表达式 1〉的值，然后计算〈表达式 2〉的值，当〈表 达式 2〉值为true时，执行一次〈循环体〉，再计算〈表达式 3〉的值，并进行下一次循环过程；当〈表达式 2〉的值为false时，循环过程结束。 在for语句中，〈表达式 1〉是给循环变量赋初值，通常是一个赋值表达式；〈表达式 2〉给出循环结束条件，因此，必须是一个关系表达式或逻辑表达 式；〈表达式 3〉改变循环变量，必须是一个赋值表达式（或类似 i++形式的改变变量i的数值的语句）；〈循环体〉可以是一条语句，也可以是多条语句，当为多条语句时，必须用一对花括号“{}”括起来。

while语句的语法形式为：

Java

1

2

while (〈逻辑表达式〉)
〈循环体〉；

while语句的语义是：如果〈逻辑表达式〉的计算结果为true，则执行循环体；如果〈逻辑表达式〉的计算结果为false，则结束while语句的执行。当〈循环体〉中的语句多于一条时，需要用一对花括号“{}”括起来。

do-while语句的语法形式为：

Java

1

2

3

4

do
{
 〈语句组〉；
} while (〈逻辑表达式〉) ；

do-while语句的语义是：首先执行语句组（或称循环体），然后计算〈逻辑表达式〉的值， 当〈逻辑表达式〉的值为true时，执行一次循环体；当〈逻辑表达式〉的值为false时，结束循环。 从语义上看，do-while语句和while语句的X差别是：do-while语句至少执行一次循环体 （因其结束条件判断在后面进行）；而对于 while 语句来说，当循环条件一开始就不满足时， 循环体将一次也不执行。从语法结构上看，与while语句的一个明显区别是do-while语句在结尾处多了一个分号。

如果循环语句的循环体内又有循环语句，则构成多重循环结构。多重循环结构中的循环语句，可以是for语句、while语句或do-while语句中的任何一种。

Java语言中提供了3种跳转语句，分别是break语句、continue语句和return语句。

break语句通常是和switch语句或循环语句配合使用的。switch语句本身并不能保证执行完一组case后的语句或语句组后，跳过随后的case判断。 通常情况下，需要用break语句来跳过随后的case语句。switch语句中的break语句的语义是：跳过break语句所在位置后所有的case语句，即结束switch语句的执行。 break语句应用在for、while和do-while循环语句中可强行退出循环，也就是忽略循环体中任何其他语句和循环条件的限制。

continue语句用于循环语句，语义是：若循环体中遇到 continue语句，则本次循环体的后续语句被忽略，回到循环条件判断处，判断是否执行下一次循环。

return语句的语法形式为：

Java

1

return [<返回值>]；

return语句的语义是：使函数返回原调用处，且带回<返回值>。如果函数为 void 类型， 则 return 语句后没有<返回值>；如果函数为非void类型，则return语句后需要有<返回值>， 并且<返回值>的类型必须和函数的类型一致。 当return语句不带<返回值>，并且位于函数的最后时，return语句可以省略。

Java语言允许在程序中添加注释，以增加程序的可读性。Java语言有单行注释、多行注释与文件注释三种形式的注释。单行注释以“//”开头，至该行行尾；多行注释以“/*”开头，以“*/”结束；文件注释以“/**”开头，以“*/”结束，用来自动生成一个HTML文档，从而为程序自动提供网络环境下的文档说明。

数组要先定义，再经过内存单元分配，才能使用。一维数组变量定义的语法形式为：

Java

1

2

〈数据类型〉〈数组名〉[]；//方法1
〈数据类型〉[]〈数组名〉；//方法2

其中，方括号[]表示定义的是数组变量，〈数据类型〉定义了数组元素的数据类型，〈数组名〉 定义了数组名的标识符。也可以把数组类型看成Java语言在基本数据类型的基础上的扩展。

如果一维数组的每个数组元素都是一个一维数组，则构成 了Java语言的二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，X个下标代表元素所在的行，第二个下标代表元素所在的列。

Java

1

2

3

//定义int类型的二维数组变量a
int a[][];
int[] a[]; 

在Java语言中，new是一个特殊的运算符，它的语义是：向系统申请指定数据类型所需的内存单元空间。new运算符返回所申请内存单元的首地址。数组元素本身的内存空间必须用new运算符申请。为数组类型变量分配内存单元的语法形式为：

Java

1

〈数组名〉= new〈数据类型〉[〈长度〉]；

其中，〈数组名〉必须是已定义的数组类型变量，〈数据类型〉必须和定义数组名时的数据类型一致，方括号[ ]内的〈长度〉为当前数组元素的个数。在数组分配内存单元后，系统将自动给每个数组元素赋初值，并规定： 数值类型的数组元素初值为0，逻辑类型的数组元素初值为false，类类型的数组元素初值为null。

字符串是n（n≥0）个字符组成的序列。为了把一个字符串和别的语言成分区分开来， Java中的字符串用一对双引号括起来，一个字符串中的字符个数称作字符串的长度。Java中的字符串变量用String来定义，但和char，int等基本数据类型不同的是，String不是一个数据类型，而是一个类。

一对双引号括起来的任何字符序列都是一个字符串常量，如""和"sun" 都是字符串常量。 字符串常量""的长度为 0，字符串常量"sun"的长度为3。

定义字符串变量的方法和定义基本数据类型变量的方法类同，在定义字符串变量时可以同时赋值，或在字符串变量定义后给该变量赋值。字符串变量名是引用类型，即字符串变量名是指向内存中一片连续内存单元的首地址。

Java

1

2

3

4

5

String str1;   									//定义字符串str1
String str2 = "sun"; 						//定义字符串str2,并赋值
str1 = "Hello";									//给str1赋值
String[] str3 = new String; //定义有三个元素的字符串数组
String[] str3={"world!","China!","sun"}; //为数组str3赋值

类是对一组相似对象的抽象描述，是面向对象方法中软件设计的主体。

类声明的格式如下：

Java

1

2

3

4

[〈修饰符〉] class〈类名〉[extends〈父类名〉] [implements〈接口名表〉]
{
 类主体
} //方括号中选项为非必要项

其中，〈修饰符〉分为访问控制符和类型说明符两部分，访问控制符和类型说明符一起使用时，访问控制符在前，类型说明符在后。类声明中的class是定义类的关键字；〈类名〉是所定义的类的名字；〈父类名〉是已经定义过的类名；〈接口名表〉是已经定义过的若干个接口名，当接口名多于一个时，用逗号分隔开；类主体设计包括类的成员变量设计和类的成员方法设计两部分。

修饰符

类型		表示
访问控制符	public	公共类
	无public	默认类（或称缺省类）
类型说明符	abstract	抽象类
	final	最终类

定义在类中的变量都是成员变量，声明一个成员变量就是声明该成员变量的名字及其所属的数据类型，同时指定其他一些附加特性。声明成员变量的格式为：

Java

1

2

 [〈修饰符〉] [static] [final] [transient]〈变量类型〉〈变量名〉；
//方括号中选项为非必要项

说明

类型		描述
修饰符	private	表示该成员变量只能被该类本身访问，任何其他类都不能访问该成员变量
	public	表示该成员变量除可以被该类本身和同一个包的类访问外，还可以被它的子类访问
	protected	修饰符表示该成员变量可以被所有类访问
static		指明该成员变量是一个类成员变量，类成员变量可以用来保存和类相关的信息，或用来在一个类的对象间交流信息
final		指明该成员变量是常量
transient		指明该成员变量是临时变量

声明成员方法的格式为：

Java

1

2

3

4

 [〈修饰符〉] [static]〈返回值类型〉〈方法名〉([〈参数列表〉]) { 
〈方法体〉 
}
//方括号中选项为非必要项

其中，〈修饰符〉和成员变量的修饰符一样，有 private、public、protected三种与默认修饰符。static指明该方法是一个类方法。方法声明中必须给出方法名和方法的返回值类型，如果没有返回值，用关键字void标记。方法名后的一对圆括号是必须的，即使参数列表为空，也要加一对空括号。方法体是方法的具体实现。

构造方法是一种专门被用来进行对象初始化的类方法，也称作构造函数，其实现过程是：在创建对象时，将调用相应类中的构造方法为对象的成员变量进行初始化赋值。构造方法在语法上等同于其他方法，但它的名字必须与其类名完全相同，并且没有返回值。构造方法一般应定义为public。构造方法用来在对象创建时为对象的成员变量进行初始化赋值。

主方法是类的入口点，它定义了程序从何处开始，提供对程序流向的控制。Java编译器通过主方法来执行程序。主方法的特点：是静态的，要直接在主方法中调用其他方法，则该方法必须也是静态的；没有返回值；形参为数组。

类中可以没有主方法，但是要运行的类中必须有主方法，因为程序是从主方法开始执行的。

类的各种方法都允许重写，也称重载，是指一个方法名定义多个方法实现。方法重写时要求，不同的方法，其参数类型或参数个数要有所不同。若类的某个方法被重写，该类的对象在访问该方法时，以对象调用该方法的参数个数和参数类型与类的同名方法进行匹配，对象调用该方法的参数个数和参数类型与类定义中哪个方法的参数个数和参数类型完全一样，则调用类中的哪个方法。

对象是类的实例化，对象就是软件系统中对具体问题的客观事物进行的具体模拟或具体描述。

对象定义后，系统将给对象标识符分配一个内存单元，用于存放实际对象在内存中的存放位置。定义对象的语句格式为：

Java

1

〈类名〉 〈对象名〉；

为对象分配内存空间需使用new运算符。为对象分配内存空间的语句格式为：

Java

1

〈对象名〉= new〈类名〉（[〈参数列表〉]）；

其中，new运算符申请对象所需的内存空间，new运算符返回所申请的内存空间的首地址。 系统将根据〈类名〉和〈参数列表〉调用相应的构造方法，为对象进行初始化赋值，即把参数值存入相应的内存单元中。赋值语句把new运算符分配的连续地址的首地址赋给对象名。 因为构造方法名和类名完全相同，所以这里的类名既用来作为new运算符的参数向系统申请对象所需的内存空间，又作为构造方法名为对象进行初始化赋值。程序设计时最经常使用的方法是在定义对象的同时为对象分配内存空间和进行初始化赋值。

定义并创建了对象后，就可以使用对象的成员变量或方法，还可以修改对象的成员变量的数值。

对象可以像变量一样赋值，但对象赋值并不是真正把一个对象的取值赋给另一个对象，而是让另一个对象名存储的对象的首地址和这个对象名存储的对象的首地址相同，即对象的赋值是对象的首地址的赋值。

对象可以作为方法的参数使用，对象作为方法的实参时，系统把实参对象名（该对象必须已创建）指示的对象的首地址赋给虚参对象名。

对象有作用范围，超出作用范围的对象（或称不再被使用的对象）称作X对象。在Java中，收集和释放内存由自动X回收线程责任。自动X回收线程在系统空闲时自动运行，这个线程监视用户程序中所有对象的有效作用范围；当某个对象超出其作用范围时，该线程就对这样的对象做上X对象标识，并在适当的时候一次性回收这些X对象。 因此，用户只需考虑为对象分配内存空间，不需考虑X对象内存空间的回收。

包（package）是Java提供的文件（即公共类）的组织方式。一个包对应一个文件夹，一 个包中可以包括许多类文件。包中还可以再有子包，称为包等级。Java 语言规定：同一个包中的文件名必须惟一，不同包中的文件名可以相同。

Java语言提供了许多方便用户程序设计的基础类，这些系统定义的类以包的形式保存在系统包文件夹中。如果要使用这些包中的类，必须在源程序中用import语句导入。

包的定义语句格式为：

Java

1

package 〈包名〉[.〈子包名〉[.〈子子包名〉…]]；

其中，package是关键字，〈包名〉是包的标识符。package语句指出该语句所在文件所有的类属于哪个包，package语句必须写在Java源程序的X行。当多个Java源程序文件中都有package语句，且package语句后的包名相同时，则说明这些类同属于一个包。 一个包还可以有子包，子包下还可以有子子包。在 package 语句中，圆点（.）起分隔作用。

Java API（Java Application Programming Interface，Java 应用程序接口），是 Java 语言提供的组织成包结构的许多类和接口的集合，包含在JDK中。Java API按照内容分别组织和存放在不同的包中。 Java API包含的内容很多，其中语言包（java.lang）与实用包（java.util）是两个最基本的包。

java.lang包是用Java语言编程时使用最频繁的包。为了简化编程，系统默认导入了 java.lang包，所以使用java.lang包中的类时可以不用import语句导入。常用的类有 Object 类、System 类、Class 类、Runtime 类、String 类、Math 类和 Float 类。

Object类是Java中所有类的根，所有其他的类都是由Object类派生出来的，因此任何Java对象都可以调用Object类的方法。

System类提供了许多获取或重新设置系统资源的静态方法，它无法实例化。System类提供标准输入、标准输出和错误输出流；访问外部定义的属性和环境变量；加载文件和库的方法；以及一种用于快速复制阵列的一部分的实用方法。

Class类的实例代表一个正在运行的Java应用程序的类或接口。Java的基本数据类型 （boolean，byte，char，shart，int，long，float，double）以及数组和关键字void都是由Class对象来表达。

Runtime类是每一个Java应用程序都有一个的实例，从而允许应用程序与其运行的环境进行交互。用户可利用 Runtime 类直接访问运行时环境资源。

Float类将基本体类型Float的值包装在对象中。Float类型的对象包含一个类型为Float的字段。这个类还提供了几个将浮点转换为String和将String转换为浮点的方法，以及处理浮点时有用的其他常量和方法。

String类表示字符串。Java程序中的所有字符串文字都是作为此类的实例实现的。String类包含用于检查序列中的各个字符、比较字符串、搜索字符串、提取子字符串以及创建所有字符都转换为大写或小写的字符串副本的方法。

Math类包含了一组基本的数X算的方法和常数。Math类中的所有方法都定义为静态的。Math类把E和PI定义为类的静态成员变量，E和PI代表数学上的相应常数。 Math类是最终类（final），所以不能从Math类中派生其他的新类。

常用方法

类	方法	描述
Object	clone()	用于创建复制出当前类对象的一个副本，得到一个复制对象
	equals(Object obj)	用来判断调用equals方法的对象和形参obj所引用的对象是否是同一对象
	getClass()	用于获取对象的运行时的真实类型
	notify()	X在对象的监视器上等待的单个线程
	notifyAll()	X在对象的监视器上等待的所有线程
	toString()	返回对象的字符串
	wait()	使当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法
	wait(long timeout)	使当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法，或者经过指定的时间
	wait(long timeout, int nanos)	使当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法，或者其他线程中断当前线程，或者经过一定的实时时间
System	arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	从指定的源数组中的指定位置开始，将数组复制到目标数组的指定位置
	currentTimeMillis()	返回当前时间（以毫秒为单位）
	exit(int status)	终止当前正在运行的Java虚拟机
	gc()	运行X收集器
	getenv()	返回当前系统环境的不可修改的字符串映射视图
	getenv(String name)	获取指定环境变量的值
	getProperties()	确定当前系统属性
	getProperty(String key)	获取由指定键指示的系统属性
	getSecurityManager()	获取系统安全接口
	load(String filename)	加载filename参数指定的本机库
	setErr(PrintStream err)	重新分配“标准”错误输出流
	setIn(InputStream in)	重新分配“标准”输入流
	setOut(PrintStream out)	重新分配“标准”输出流
	setProperties(Properties props)	将系统属性设置为properties参数
	setProperty(String key, String value)	设置由指定键指示的系统属性
	setSecurityManager(SecurityManager s)	设置系统安全性
Class	forName(String className)	返回与具有给定字符串名称的类或接口关联的Class对象
	forName(String name, boolean initialize, ClassLoader loader)	使用给定的类加载器，返回与具有给定字符串名称的类或接口关联的Class对象
	getClasses()	返回一个数组，该数组包含表示所有公共类的Class对象和接口，这些公共类和接口是由该Class对象表示的类的成员
	getClassLoader()	返回类的类加载器
	getConstructor(Class<?>... parameterTypes)	返回一个构造函数对象，该对象反映由该class对象表示的类的指定公共构造函数
	getConstructors()	返回一个数组，该数组包含构造函数对象，该构造函数对象反映由该class对象表示的类的所有公共构造函数
	getDeclaredMethod(String name, Class<?>... parameterTypes)	返回一个Method对象，该对象反映由该class对象表示的类或接口的指定声明方法
	getDeclaredMethods()	返回一个数组，该数组包含反映该class对象所表示的类或接口的所有声明方法的Method对象，包括公共、受保护、默认（包）访问和私有方法，但不包括继承的方法
	getField(String name)	返回一个Field对象，该对象反映由该class对象表示的类或接口的指定公共成员字段
	getFields()	返回一个数组，该数组包含反映该class对象所表示的类或接口的所有可访问公共字段的Field对象
	getMethod(String name, Class<?>... parameterTypes)	返回一个方法对象，该对象反映由该class对象表示的类或接口的指定公共成员方法
	getMethods()	返回一个数组，该数组包含反映由该class对象表示的类或接口的所有公共方法的Method对象，包括由该类或接口声明的方法以及从超类和超接口继承的方法
	getName()	以字符串形式返回此class对象表示的实体（类、接口、数组类、基元类型或void）的名称
	getPackage()	获取类的包
	getResource(String name)	查找具有给定名称的资源
	getSuperclass()	返回表示由该类表示的实体（类、接口、基元类型或void）的超类的类
	isAnnotation()	如果此Class对象表示注释类型，则返回true
	isArray()	确定此Class对象是否表示数组类
	isEnum()	当且仅当此类在源代码中声明为枚举时，返回true
	isPrimitive()	确定指定的Class对象是否表示基元类型
Runtime	exit(int status)	通过启动当前运行的Java虚拟机的关闭序列来终止该虚拟机
	freeMemory()	返回Java虚拟机中的可用内存量
	gc()	运行X收集器
	getRuntime()	返回与当前Java应用程序关联的运行时对象
	totalMemory()	返回Java虚拟机中的内存总量
	traceInstructions(boolean on)	启用/禁用指令跟踪
	traceMethodCalls(boolean on)	启用/禁用方法调用的跟踪
Float	compare(float f1, float f2)	比较两个指定的浮点值
	compareTo(Float anotherFloat)	比较两个Float对象的数值
	doubleValue()	以双精度形式返回此Float的值
	floatValue()	返回此Float对象的浮点值
	intValue()	在缩小基元转换后，以int形式返回此Float的值
	max(float a, float b)	返回两个浮点值中较大的一个
	min(float a, float b)	返回两个浮点值中较小的一个
	sum(float a, float b)	将两个浮点值相加
	valueOf(float f)	返回表示指定浮点值的浮点实例
	valueOf(String s)	返回一个Float对象，该对象包含由参数字符串s表示的浮点值
String	compareTo(String anotherString)	按字典顺序比较两个字符串
	length()	返回字符串的长度
	substring(int beginIndex)	返回当前字符串的由beginIndex开始到结尾的子串
	substring(int beginIndex, int endIndex)	返回当前字符串的由beginIndex开始到endIndex结尾的子串
	toLowerCase()	使用默认区域设置的规则将字符串中的所有字符转换为小写
	toUpperCase()	使用默认区域设置的规则将字符串中的所有字符转换为大写
Math	abs( a)	返回a的X值
	cos(double a)	返回角度的余弦值
	max(a,b)	返回两个值中的较大值
	min(a, b)	返回两个值中的较小值
	random()	返回一个带正号的双精度值，该值大于或等于0.0且小于1.0
	sin(double a)	返回角度的正弦值
	sqrt(double a)	返回双精度值正平方根
	tan(double a)	返回角度的正切值

java.util包主要包含集合框架、事件模型、日期和时间机制、国际化等的类和接口，常用的类和接口有Arrays类、Vector类、Data类和Enumeration接口。

Arrays类是Java集合框架的成员。这个类包含各种操作数组的方法（例如排序和搜索）。此类还包含一个静态工厂，该工厂允许将数组作为列表进行查看。如果指定的数组引用为null，则该类中的所有方法都会抛出NullPointerException，除非另有说明。

Vector类称作向量类，它实现了动态的数组，用于元素数量变化的对象数组。像数组一样，Vector类也用从0开始的下标表示元素的位置；但和数组不同的是，当Vector对象创建后，数组的元素个数会随着Vector对象元素个数的增大和缩小变化。

Data类提供了获取当前精确到毫秒时间的方法，并提供了许多方法截取当前时间的年、 月、日等数值。

Calendar类是一个抽象类，它提供了在特定时刻和一组日历字段（如YEAR、MONTH、DAY_of_MONTH、HOUR等）之间进行转换的方法，以及操作日历字段的方法。

Enumeration接口主要用于集合类对象的序列化。任何一个类，只要实现了Enumeration接口，其对象就是序列化的。所谓对象是序列化的，就是说若连续调用 nextElement()方法，每次将返回该集合对象当前元素的后续元素。

常用方法

类和接口	方法	描述
Arrays	binarySearch([] a, byte key)	使用二进制搜索算法在指定的数组中搜索指定的值
	binarySearch([] a, int fromIndex, int toIndex, byte key)	使用二进制搜索算法在指定数组的范围内搜索指定值
	sort([] a)	按升序对指定的数组进行排序
	sort([] a, int fromIndex, int toIndex)	按升序对数组的指定范围进行排序
Vector	add(E e)	将指定的元素追加到向量的末尾
	add(int index, E element)	在向量中的指定位置插入指定的元素
	addAll(Collection<? extends E> c)	按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到向量的末尾
	addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到向量的指定位置
	addElement(E obj)	将指定的组件添加到向量的末尾，使其大小增加一
	copyInto(Object[] anArray)	将向量的分量复制到指定的数组中
	elements()	返回向量的组件的枚举
	removeElement(Object obj)	从向量中删除参数的X个（索引最低的）引用
	size()	返回向量中的元素个数
Date	after(Date when)	若当调用此方法的Date对象在指定日期之后返回true,否则返回false
	before(Date when)	若当调用此方法的Date对象在指定日期之前返回true,否则返回false
	clone()	返回对象的副本
	compareTo(Date anotherDate)	比较当调用此方法的Date对象和指定日期
	equals(Object obj)	当调用此方法的Date对象和指定日期相等时候返回true,否则返回false
	getTime()	返回自1970年1月1日 00:00:00 GMT 以来，对象表示的毫秒数
	hashCode()	返回对象的哈希码值
	setTime(long time)	用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期
	toString()	把对象转换为以下形式的字符串： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 （Sun, Mon, Tue, Wed, Thu, Fri, Sat）
Calendar	add(int field, int amount)	根据日历的规则，在给定的日历字段中添加或减去指定的时间量
	get(int field)	返回给定日历字段的值
	getTime()	返回一个Date对象，表示此日历的时间值（从Epoch开始的毫秒偏移量）
	set(int field, int value)	将给定的日历字段设置为给定的值
	setTime(Date date)	将日历的时间设置为给定日期
Enumeration	nextElement()	返回后续元素
	hasMoreElements()	判断是否还有后续元素

Java开发工具包（Java Development Kit）是Java开发工具包，包括Java类库、Java编译器、Java解释器、Java运行环境和Java命令行工具。JDK提供Java程序的编译和运行命令，但没有提供程序编辑环境。Java运行环境（Java Runtime Environment，JRE）：Java运行环境主要包含Java虚拟机（Java Virtual Machine，JVM）和Java函数库。JVM是一套支持Java语言运行的软件系统，定义了指令集、寄存器集、类文件结构栈、X收集堆、内存区域等，提供了跨平台能力的基础框架。

在选择JDK开发Java程序时，需使用文本编辑器编写Java源程序，在DOS窗口中编译与运行Java程序。

Eclipse是IBM公司开发的Java IDE。Eclipse具有开放的功能扩展包，可以依照开发者自己的习惯进行配置。其web开发工具Wild Web Developer为最新版本的TypeScript和Angular提供版本支持。Eclipse具有安全功能，如强制使用https协议、PGP密钥吊销处理、跟踪受信任的主机和不受信任的工件处理

MyEclipse是IBM公司开发的Java IDE。MyEclipse提供Java EE库和功能，支持部署到几十个企业友好的应用服务器进行快速检测。使用MyEclipse内置功能连接到云，支持探索和连接服务。MyEclipse支持快速添加技术功能到Web项目中，使用可视化编辑器以便编码和配置，并且还可以在多种应用服务器上测试任务。MyEClipse支持使用Java、HTML和JQuery进行编码，使用移动工具创建拥有良好编码的应用，并嵌入到原生iOS和Android应用中，便于移动应用开发。

MyEclipse界面

IntelliJ IDEA简称IDEA，是由JetBrains公司开发的Java编程语言开发集成环境程序，具有智能代码补全、框架针对性辅助、远程开发的特点。用户使用该程序编辑器时，可通过编码辅助功能搜索可能的错误并在输入时获得改进建议，同时了解编码、新语言功能等方面的内容。IntelliJ IDEA具备深度代码理解，可以为用户提供相关编码建议，实现极快的导航和智能体验。IntelliJ IDEA有丰富的工具集，任务关键型工具和多种支持语言与框架的使用较为方便，无需另外安装插件。

IntelliJ IDEA界面

Apache Maven是一个构建和项目管理工具，可以用于构建和管理任何基于Java的项目。基于项目对象模型（POM）的概念，Maven可用于管理项目的生成、报告和文档记录。

Maven的特点有：开发人员可以在几秒钟内启动新项目或模块；X的依赖关系管理，包括自动更新、依赖关系关闭（也称为传递依赖关系）；能够轻松地同时处理多个项目；拥有一个庞大且不断增长的库和元数据存储库，使用便捷且可以实时获得其最新版本；可扩展，能够轻松地用Java或脚本语言编写插件；只需很少或根本不需要额外配置即可即时访问新功能；能够将任意数量的项目构建为预定义的输出类型，在大多数情况下不需要执行任何脚本；使用与构建过程相同的元数据，Maven能够生成一个网站或PDF，包括想要添加的任X档，并添加到有关项目开发状态的标准报告中；在没有太多额外配置的情况下，Maven将与用户的源代码管理系统集成，并基于某个标签管理项目的发布，它还可以将其发布到分发位置，供其他项目使用；Maven能够发布单独的输出；Maven鼓励使用JAR和其他依赖关系的中央存储库。

Gradle Build Tool是一款快速、可靠、适应性强的开源构建自动化工具，具有优雅且可扩展的声明性构建语言，可以构建任何规模和复杂性的项目，支持Android、Java、 Kotlin、 Groovy、Scala、Javascript和C/C++。Gradle是JVM流行的构建系统，也是Android和Kotlin多平台项目的默认系统。它有一个丰富的社区插件生态系统，可以使用其内置功能、第三方插件或自定义构建逻辑来自动化各种软件构建场景。Gradle提供了一种高级、声明性和表达性的构建语言，使其易于阅读和编写构建逻辑。Gradle可以产生可靠的结果，同时受益于增量构建、构建缓存和并行执行等优化。

异常是指程序在执行过程X现的意外事件，它通常会使程序的正常流程被打断。Java采用面向对象的异常处理机制，使正常代码和错误处理代码分开，这样程序的业务逻辑更加清晰明了，并且能够简化错误处理任务。

Java的所有异常类都继承自Throwable类，可以分为两大类：Error类和 Exception类。

Error类指的是系统异常或运行环境出现的异常，这些异常一般是很严重的异常。程序一般不用捕捉Error错误，由系统进行这类错误的捕捉和处理。Error类及其子类定义了系统中可能出现的大多数Error错误。

Exception类指的是一般的异常，如输入/输出（I/O）异常、数据库访问（SQL）异常等，对这些异常应用程序可以进行处理。Exception类有较多的子类，可分为检查性常类和运行时异常。Exception类异常和任何不属于RuntimeException子类的子类都是已检查的异常 。 RuntimeException是Java虚拟机正常操作期间可以抛出的异常的超类。RuntimeException及其子类是未检查的异常。

Error类的子类

名称	描述
AnnotationFormatError	当注释分析器尝试从类文件读取注释并确定该注释格式不正确时抛出。此错误可能由用于反射式读取注释的API引发
AssertionError	抛出以指示断言已失败
AWTError	当出现严重的抽象窗口工具包错误时抛出
CoderAlfunctiоnError	CharsetDecoder的decodeLoop方法或CharsetEncoder的encodeLoop方法引发意外异常时引发错误
FactoryConfigurationError	当存在Parser Factories配置问题时抛出。 当无法找到或实例化系统属性中指定的解析器工厂的类时，通常会抛出此错误
IOError	发生严重I / O错误时抛出
LinkageError	某个类对另一个类有一些依赖性; 然而，后一类在前一类的编译后发生了不相同的变化
SchemaFactoryConfigurationError	当存在与Schema Factories配置的问题时抛出。 当无法找到或实例化系统属性中指定的模式工厂的类时，通常会抛出此错误
ServiceConfigurationError	在查找，加载或实例化服务提供者时出现错误时抛出错误
ThreadDeath	调用Thread.stop()方法时，可能会抛出ThreadDeath的实例
TransformerFactoryConfigurationError	当存在Transformer Factories配置问题时抛出。 当无法找到或实例化系统属性中指定的转换工厂的类时，通常会抛出此错误
VirtualMachineError	抛出此异常表示Java虚拟机已损坏或已耗尽其继续运行所需的资源

常见异常类

类型	异常	描述
运行时异常	ArithmeticException	算术运算异常
	ArrayIndexOutOfBoundsException	数组下标越界异常
	ArrayStoreException	数组存储异常
	ClassCastException	类型转换异常
	IllegalArgumentException	非法参数异常
	IllegalMonitorStateException	非法监视状态异常
	IllegalThreadStateException	非法线程状态异常
	IndexOutOfBoundsException	下标超出范围异常
	NegativeArraySizeException	负数组个数异常
	NullPointerException	空指针异常
	NumberFormatException	数字格式异常
	SecurityException	安全异常
	EmptyStackException	空栈异常
	NoSuchElementException	没有元素异常
检查性异常	ClassNotFoundException	找不到类异常
	CloneNotSupportedException	复制不支持异常
	IllegalAccessException	非法访问异常
	InstantiationException	实例异常
	InterruptedException	中断异常
	IOException	输入/输出异常
	FileNotFoundException	找不到文件异常
	InterruptedIOException	中断输入/输出异常

在Java程序中，用try-catch（或 try-catch-finally）语句来抛出、捕捉和处理异常。try-catch-finally语句的语法格式是：

Java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

try
{ 
 可能抛出异常的语句模块；
}
catch （异常类型 1 ）
{
 处理异常类型 1 语句；
}
……
catch （异常类型 n ）
{
 处理异常类型 n 语句；
}
finally
{
 无论是否抛出异常都要执行的语句；
} 

try模块中的语句是程序正常流程要执行的语句，但是在执行过程中有可能出现异常。程序中没有try模块时，若出现了系统定义的异常，系统也会自动抛出，并由系统负责捕捉和处理。

try模块中的语句可能抛出很多不同类型的异常，可针对不同类型的异常分别设计catch模块。如果try模块抛出异常，系统会按catch模块的排列顺序依次查找。当所有的catch模块中都匹配不上时，由虚拟机来处理异常。

finally模块中的语句是必须执行的语句。无论try模块中是否抛出异常，finally模块中的 语句都要被执行。这个模块是可选的。finally模块通常被用来做一些资源回收的工作。

throws通常用于方法声明，当方法中可能存在异常，却不想在方法中对异常进行处理时，就可以在声明方法时使用throws声明出的异常，然后在调用该方法的其他方法中对异常进行处理。throws可以声明抛出多个异常类，多个异常类之间以逗号隔开，语法格式如下：

Java

1

throws 〈异常类〉， 〈异常类〉...

使用throws声明抛出异常时有一个限制：子类方法中声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相等，子类方法中不允许比父类方法声明抛出更多异常。

当程序出现错误时，系统会自动抛出异常；除此之外，Java也允许程序自行抛出异常，自行抛出异常使用throw语句完成。throw语句可以单独使用，throw语句抛出的不是异常类，而是一个异常实例，且每次只能抛出一个异常实例。throw语句语法格式：

Java

1

throw〈异常类对象〉; 

应用程序中除了可能出现系统定义的异常外，有时还可能出现系统没有考虑的异常，此时则需要在应用程序中自定义异常类。一般情况下，自定义的异常类都是一些应用程序可以处理的异常。用户自定义异常都应该继承Exception基类。定义异常类时通常需要提供两种构造器：一个是无参数的构造器；另一个是带一个字符串的构造器，这个字符串将作为该异常对象的详细说明，即异常对象的getMessage方法的返回值。

Java把所有输入和输出都当作流来处理。流是按一定顺序排列的数据的集合，例如，字符文件、声音文件或图像文件等都可以看作是一个个的数据流。输入和输出的方向是以程序为基准的。向程序输入数据的流定义为输入流，从程序输出数据的流定义为输出流。Java的输入/输出流中，根据它们的数据类型，主要可分为两类：字节流和字符流。

输入输出流

类型	描述	基本类
字节流	用于读/写二进制数据	InputStream 类、OutputStream类
字符流	输入/输出数据是Unicode字符	Reader类、Writer类

Java的标准数据流指程序和DOS交互时的输入/输出方式。java.lang包的System类定义了三个成员变量：标准输入static final InputStream in、标准输出static final PrintStream out、标准错误输出static final PrintStream err。因为这三个成员变量都是静态成员变量，即类成员变量，所以可以直接使用， 不需要创建对象。

常用方法

-	方法	描述
屏幕输入 in	System.in.read()	用于返回从键盘输入的字符
	System.in.read(byte[] b)	从键盘输入多个字符到数组b，并返回字符个数
屏幕输出 out	System.out.print(String str)	向屏幕输出字符串
	System.out.println(String str)	向屏幕输出字符串后换行

Java语言定义了许多类专门负责各种方式的输入/输出，这些类都被放在java.io包中。其中，所有输入流类都是抽象类InputStream（字节输入流）或抽象类Reader（字符输入流）的子类，而所有输出流都是抽象类OutputStream（字节输出流）或抽象类Writer（字符输出流）的子类。

InputStream类称作字节输入流类，为其他输入字节流子类提供了一些基本方法和标准接口。Reader类称作字符输入流类，Reader类为通用的输入字符流提供了一些基本方法和标准接口。 Reader类和InputStream类的很多方法很相似，它们的主要区别是：InputStream类操作的是字节，Reader类操作的是字符。

OutputStream类称作字节输出流类，为其他的输出字节流子类提供了一些基本方法和标准接口。Writer类及其子类Writer类称作字符输出流类，为通用的输出字符流提供了一些基本方法和标准接口。Writer类和OutputStream类的很多方法很相似，它们的主要区别是：OutputStream类操作的是字节，Writer类操作的是字符。

常用方法

-	方法	描述
InputStream类	abstrac int read()	从输入流读下一个字节
	void close()	关闭输入字节流
Reader类	int read()	从输入流读下一个字符
	abstract void close()	关闭输入字符流
OutputStream类	abstract void write(int b)	将字节b写到输出流
	void close()	关闭输出字节流
Writer类	void write(int c)	将字符c写到输出流
	abstract void close()	关闭输出字符流

常用子类

-	子类	描述
InputStream类	BufferedInputStream	产生一个内部缓冲数组，可以根据需要从连接的输入数据流中一次性读多个字节的数据到内部缓冲数组中
	FileInputStream	主要用于文件的输入，创建的对象可以顺序地从本地机上的文件中读数据
Reader类	BufferedReader	缓冲字符输入流，它在字符输入流的基础上，增加了字符缓冲的功能
	InputStreamReader	将字节输入流转换成字符输入流的转换器。有子类FileReader类，用于读取字符文件
OutputStream类	BufferedOutputStream	产生一个内部缓冲数组，从连接的输出数据流中一次性向内部缓冲数组中写多个字节的数据
	FileOutputStream	主要用于文件的输出，它的对象可以顺序地向本地机上的文件中写数据
Writer类	BufferedWriter	缓冲字符输出流，它在字符输出流的基础上，增加了字符缓冲的功能
	OutputStreamWriter	将字符输出流转换成字节输出流的转换器。有子类FileWriter类，用于字符文件输出

对象都有一定的生命周期。对象流可以将一个对象生命周期的某一阶段的状态保存下来，当需要的时候，再将保存的对象状态恢复。对象流有对象输入流ObjectInputStream类和对象输出流ObjectOutputStream类。 ObjectInputStream类是 InputStream类的子类，它主要用于对象的恢复。ObjectOutputStream类是 OutputStream类的子类，它主要用于对象的保存。

对象流中的对象通常不止一个，为了保证保存和恢复的对象不会出错，必须保证这些对象都是序列化的对象。序列化的对象是指能够按顺序操作对象流中的对象。一个类如果实现了Serializable接口，它的对象就是序列化的对象。Serializable接口的定义如下：

Java

1

public interface Serializable(){} 

这个接口是空的，其中没有定义任何方法，因此实现这个接口非常简单，仅需在类定义时，包含implements Serializable就可以了。

进行对象流的保存（或称写）时需要注意，只能保存对象的非静态成员变量，不能保存 任X态的成员变量，而且保存的只是变量的当前值，对于变量的任何修饰符都不能保存。

File类是io包中X代表磁盘文件本身的对象，定义了一些与平台无关的方法来操作文件，可以通过调用File类中的方法，实现创建、删除、重命名文件等。File类的对象主要用来获取文件本身的一些信息。

RandomAccessFile类被称作随机存取文件类，它提供了随机访问文件的方法。和输入/输出流类相比，RandomAccessFile类有两点不同：RandomAccessFile类是直接继承自对象类Object，同时实现了DataInput接口和DataOutput接口；RandomAccessFile 类既可以作为输入流，又可以作为输出流。 RandomAccessFile类之所以允许随机访问文件，是由于它定义了一个文件当前位置指针， 文件的存取都是从文件当前位置指针指示的位置开始的。通过移动这个指针，就可以从文件的任何位置开始进行读/写操作。

常用方法

类	方法	描述
File	canRead()	是否可读
	canWrite()	是否可写
	isFile()	是否是文件
	isDirectory()	是否是目录
	exists()	是否存在
	length()	返回文件的长度
	lastModified()	返回文件的最后修改时间
	getName()	返回文件名
	getPath()	返回文件的路径
	getParent()	返回文件的上一级目录
	mkdir()	创建文件的目录 ，返回true为成功，false为失败
	delete()	删除文件，返回true为成功，false为失败
	renameTo(File name)	重命名文件name，返回true为成功，false为失败
	getAbsolutePath()	返回文件的X路径
	isHidden()	是否是隐藏文件
RandomAccessFile	getFilePointer()	返回文件指针
	length()	返回文件长度
	seek(long position)	文件指针到达位置position
	read()	从文件读入一个字节
	read(byte[] b)	从文件读入b.length个字节存入数组b中
	read(byte[], int off, int len)	从文件当前位置指针为off开始读入len个字节存入数组b
	readLine()	从文件读入一行字节
	write(int b)	向文件中写入字节b
	write(byte[] b)	把数组b中的字节全部写入文件中
	write(byte[] b, int off, int len)	把数组b中len个字节写入文件中文件当前位置指针为off开始的位置
	writeChars(String s)	向文件中写入字符串s

Java是原生支持多线程编程的。采用多线程机制可以并发处理多个任务，并且互不干涉，不会由于某一任务处于等待状态而影响其他任务的执行。

Thread（线程）类和 Runnable（可运行）接口提供了支持线程的功能。由于Thread 类和Runnable接口是在java.lang（语言）包中，所以使用Thread类和Runnable接口时不需要使用import导入语句。

Thread类是Java中支持多线程机制的一个重要类，它提供了很多控制和调度线程的方 法。这些方法包括：启动、睡眠、运行等。

如果要设计一个包含线程的程序，一种常用的方法是继承Thread类，并要在这个类中实现run()方法。程序设计时，把想要运行的程序代码（即线程） 放入run()方法中。当创建了一个线程对象后，可以用start()方法来启动这个线程，start()方法通过自动调用run()方法来执行当前线程包含的代码。

Thread类

-	变量与方法	描述
常用成员变量	MIN_PRIORITY	线程可以拥有的最小优先级
	MAX_PRIORITY	线程可以拥有的最大优先级
	NORM_PRIORITY	线程默认的优先级
构造方法	Thread()	Runnable是系统的Runnable接口，这里表示实现了Runnable接口的类；target是执行线程体的目标对象；name为线程名；ThreadGroup是系统的线程组类；group是线程所属的线程组的名称
	Thread(Runnable target)
	Thread(Runnable target，String name)
	Thread(String name)
	Thread(ThreadGroup group，Runnable target)
	Thread(ThreadGroup group，String name)
常用方法	void run()	运行线程
	void start()	启动线程
	static void sleep(long millis)	指定当前运行线程休眠millis毫秒

任何实现Runnable接口的类都支持多线程。在Runnable接口中只有一个方法：run()。

要设计线程程序，用继承Thread类方法比用实现Runnable接口方法更简单，因为用实现Runnable接口方法设计时，要使用Thread类提供的方法必须定义Thread类的对象，即通过Thread类的对象来调用Thread类的方法。Runnable接口主要用于多继承。

线程的生命周期是指线程从创建、运行到死亡的过程。在一个线程的生命周期内，可以有五种状态，即创建、可运行、运行中、不可运行（或称阻塞）和死亡状态。通过对线程的控制和调度，一个线程可以在这五种状态之间转换。Thread类中提供的方法和Object类提供的wait()和notify()方法可以在程序中改变线程的状态。

创建：当程序使用new关键字创建了一个线程之后，该线程就处于新建状态。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程执行体中的线程执行体。

可运行：在调用了新创建线程对象的start方法后，线程就处于可运行状态。 可运行状态的线程可能会同时有很多，这些可运行状态的线程在一个优先级队列中排队， 等待操作系统的线程调度程序调度。

运行中：若处于可运行状态的线程获得了CPU，并开始执行run方法的线程执行体，则该线程处于运行状态。如果计算机只有一个CPU，那么在任何时刻只有一条线程处于运行状态。

不可运行状态：不可运行状态也称为阻塞状态，是指因为某种原因系统不能执行线程的状态。这时就是处理器空闲也不能执行该线程。 进入不可运行状态的原因通常有：线程调用了sleep()方法；线程调用了Object类的wait()方法； 输入/输出流中发生了线程阻塞。

死亡状态：线程会以正常结束、抛出异常结束或stop()方法结束等三种方式之一结束，结束后就处于死亡状态。

每一个线程都是一个线程组的成员。线程分组提供了一个统一管理多个线程而不需单独管理的机制。Java语言的java.lang包中的ThreadGroup子包提供了实现线程分组的类。

ThreadGroup类

-	方法	描述
构造方法	ThreadGroup(String name)	name是线程组名
	ThreadGroup(ThreadGroup parent, String name)	name是线程组名，parent是父线程组名，默认值是当前线程组
常用方法	String getName()	可返回当前线程组名
	int activeCount()	可获得本组活动线程的数目
	int enumerate(Thread[] list)	将本组活动线程拷贝到数组list中

为了避免多个并行运行的线程对共享资源操作时出现问题，Java语言引入了互斥锁。互斥锁是基于共享资源的互斥性设计的，用来标记那些多个并行运行的线程共享的资源。 被互斥锁标记的共享资源，在一个时间段内，只能有一个线程使用；只有当加互斥锁的线程使用完了该共享资源，另一个线程才可以使用。这样就可以保证线程对共享资源操作的正确性。

关键字synchronized是用来给共享资源加互斥锁的。当某个共享资源被用synchronized修饰时，就表明该共享资源在某段时间内只能由加锁的线程访问。为共享资源加互斥锁有锁定一个对象和一段代码或锁定一个方法两种方法。

锁定一个对象和一段代码声明格式为：

Java

1

synchronized (〈对象名〉) { 〈语句组〉 } 

对象表示要锁定的共享资源；花括号内的语句组表示锁定对象期间执行的语句，表示对象的锁定范围。此格式可以用来在一个线程的一部分代码上加互斥锁。 当一个线程执行这段代码时，就锁定了指定的对象。此时，如果其他线程也要对加了互斥锁的对象进行操作，就无法进行；其他线程必须等候，直到该对象的锁被释放为止。加锁的线程执行完花括号内的语句后，将释放对该对象加的锁。这就形成了多个线程对同一个对象的“互斥”使用方式，因此该对象也称为互斥对象。

锁定一个方法声明格式为：

Java

1

synchronized 〈方法声明〉 { 〈方法体〉 } 

此格式锁定的是方法所属类的对象，锁定的范围是整个方法，即在一个线程执行整个方法期间对该方法所属类的对象加互斥锁。

Object类提供了一组关于线程同步的方法：wait()方法和 notify()方法。wait()方法是把当前线程从运行状态转为阻塞状态；notify()方法是把等待线程从阻塞状态转为可运行状态，从而有机会让线程调度程序调度进入运行状态。wait()方法所在的代码段一定要加互斥锁synchronized，因为wait()方法在把当前线程从运行状态转为阻塞状态后，还要释放互斥锁锁定的共享资源（否则其他同步线程无法运行），这样的操作不允许中间被打断。

设计一个日期类，判断某个日期坐在年份是否为闰年，若为闰年则输出所在月份的总天数，若不是闰年则输出几年后为闰年。

Java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

public class Date{ //类声明
    
    private int year; //成员变量，表示年
    private int month; //成员变量，表示月
    private int day; //成员变量，表示日

    public Date(int y, int m, int d){ //构造方法
        if (y < 0 || m < 0 || d <0) { //逻辑运算，判断数字是否小于0，如果是，则抛出一个IllegalArgumentException异常
            throw new IllegalArgumentException("数字必须为正"); 
        }
        year = y;
        month = m;
        day = d;
    }

    public Date(){ //构造方法重写
        year = 2004;
        month = 8;
        day = 10;
    }

    //以下为其他类方法

    public void PrintDays()    { //输出当月天数
        switch (month) {    //switch语句
            case 1: case 3: case 5: case 7: case 8: case 10: case 12:
                System.out.println("选择的月份有31天");
                break;
            case 4: case 6: case 9: case 11:
                System.out.println("选择的月份有30天");
                break;
            case 2:
                System.out.println("选择的月份有29天");
                break;
            default:
                System.out.println("Data Error!");
        }
    }

    public boolean IsLeapYear(){ //判断是否闰年
        return (year % 400 == 0) | (year % 100 != 0) & (year % 4 == 0);
    }

    public static void main(String[] args){ //main()方法
        Date a = new Date(2004, 8, 5); //创建对象
        Date b;
        b = a; //对象间赋值
        a.year = 2005;//修改对象的成员变量
        if (b.IsLeapYear()) {   //if-else 结构
            System.out.println(b.year + "年是闰年");
            b.PrintDays();
        } else {
            System.out.println(b.year + "年不是闰年");
            int num = 0;
            while (!b.IsLeapYear()) { //while语句循环直到得到闰年
                b.year ++; //自加运算
                num ++;
            }
            System.out.println(num + "年后是闰年");
        }
        //System.out.println(num + " 是闰年"); 运行该段代码时，编译器将报错，因为输出语句与变量num不在一层程序块中
    }
}
//输出结果：
//2005年不是闰年
//3年后是闰年

Java的安全模型是其多个重要结构特点之一，它使Java成为适于网络环境的技术。

Java沙箱是一种让Java应用程序在一个受限的环境中运行的机制，其目的是保护系统和用户的安全。沙箱能够在应用程序中启用一些安全管理功能，以保护系统和用户的安全，防止应用程序意外或恶意地破坏系统。

类加载器可以在将类加载到虚拟机中的时候检查类的完整性。在Java沙箱中，类装载器X结构是X道防线。类装载器X结构在三个方面对Java的沙箱起作用：防止恶意代码去干涉善意的代码；守护了被信任的类库的边界；将代码归入某类（保护域）。

类装载器X结构可以防止恶意的代码去干涉善意的代码，这是通过为不同的类装载器装入的类提供不同的命名空间来实现的。命名空间由一系列X的名称组成，每一个被装载的类有一个名字，这个命名空间是由Java虚拟机为每一个类装载器维护的。

类装载器X结构守护了被信任的类库的边界，这是通过分别使用不同的类装载器装载可靠的包和不可靠的包来实现的。虽然通过赋给成员受保护（或包访问）的访问限制，可以在同一个包中的类型间授予彼此访问的特殊权限，但这种特殊的权限只能授给在同一个包中的运行时成员，而且它们必须是由同一个类装载器装载的。

类装载器要知道一个类是否来源于一个被禁止的包，需要通过它的类名来检测。除了屏蔽不同命名空间中的类以及保护被信任的类库的边界外，类装载器还起到另外的安全作用。类装载器必须将每一个被装载的类放置在一个保护域中，一个保护域定义了这个代码在运行时将得到怎样的权限。

当类加载器将新加载的Java平台类的字节码传递给虚拟机时，这些字节码首先要接受校验器的校验。校验器负责检查那些指令无法执行的明显有破坏性的操作。除了系统类外，所有的类都要被校验。

字节码检验器要进行大量的检查，以确保采用任何路径在字节码流中都得到一个确定的操作码，确保操作数栈总是包含正确的数值以及正确的类型。它必须保证局部变量在赋予合适的值以前不能被访问，而且类的字段中必须总是被赋予正确类型的值，类的方法被调用时总是传递正确数值和类型的参数。字节码检验器还必须保证每一个操作码都是合法的，即每一个操作码都有合法的操作数，以及对每一个操作码，合适类型的数值位于局部变量中或是在操作数栈中。这些仅仅是字节码检验器所做的大量检验工作中的一小部分，在整个检验过程通过后，它就能保证这个字节码流可以被Java虚拟机安全地执行。

安全管理器是一个负责控制具体操作是否允许执行的类。安全管理器负责检查的操作包括：创建一个新的类加载器；退出虚拟机；使用反射访问另一个类的成员；访问本地文件；打开socket连接；启动打印作业；访问系统剪贴板；访问AWT事件队列；打开一个顶层窗口。

每个类都有一个保护域，它是一个用于封装类的代码来源和权限集合的对象。当Security Manager类需要检查某个权限时，它要查看当前位于调用堆栈上的所有方法的类，然后它要获得所有类的保护域，并且询问每个保护域，其权限集合是否允许执行当前正在被检查的操作。如果所有的域都同意，那么检查得以通过。否则，就会抛出一个 Security Exception异常。在运行Java应用程序时，默认设置不安装安全管理器。

Java使用AWT和Swing类完成图形用户界面编程，其中AWT的全称是抽象窗口工具集(Abstract Window Toolkit)，它是Sun公司最早提供的GUI库，这个GUI库提供了一些基本功能，但这个GUI库的功能比较有限，所以后来又提供了Swing库。通过使用AWT和Swing提供的图形界面组件库，程序只要依次创建所需的图形组件，并以合适的方式将这些组件组织在一起，就可以开发出用户界面。在设计图形用户界面后，通过相关的类或接口进X件处理，就可以实现使用界面来控制相关程序的执行。

Web应用提供Internet的浏览服务。Java早期采用Applet技术实现动态Web页面设计，目前采用JSP等技术实现服务端的动态Web页面设计。

Java Applet是运行于各种网页文件中， 用于增强网页的人机交互、动画显示、声音播放等功能的程序。 Java Applet能够跨平台地运行于网络中各种不同类型的计算机上。客户端的计算机，只要安装了支持Java的浏览器，并且和网络中的服务器建立了连接，就可以从服务器下载嵌入了Applet的网页文件，并在本地机的浏览器上运行含有 Applet的网页。

JSP（Java Server Pages）是Sun公司1999年推出的一种X页技术标准，它在HTML文档中嵌入Java语言，是运行于Web服务端的标记语言。JSP基于JavaX的Web开发技术，可以建立跨平台安全、高效的X站。

Java提供JDBC，支持数据库应用。JDBC(Java DataBaseConnectivity，Java数据库连接) 是Java访问关系数据库的应用程序接口，提供多种数据库驱动程序类型，提供执行SQL语句来操纵关系数据库的方法，使Java应用程序具有访问不同类型数据库的能力。

在Java中有许多与网络通信有关的类和接口，利用它们可以方便地实现网上资源的定位和获取，以及实现计算机之间的通信和文件的传输等。Java用于网络通信的包是 java.net，它包含了多个用于各种标准网络协议通信的类和接口。java.net提供了两个类：Socket类和ServerSocket类，分别用来表示双向连接的客户机端Socket和服务器端Socket。在创建了Socket对象和ServerSocket对象后调用相应的方法，就可以实现网络通信。

Java EE是Java的企业级应用平台，它以Java SE为基础向外延伸，增加了许多支持企业内部使用的扩充类，提供分布式企业软件组件架构规范，具有开放性、可扩展性、集成性和Java EE服务器之间的互操作性。它支持使用多层架构的企业应用如企业资源计划 （ERP）系统、客户关系管理（CRM)）系统。

嵌入式系统开发所选择的语言有很多种，由于Java语言具有跨平台，纯面向对象以及网络编程等优点，使其在嵌入式系统软件开发中崭露头角。 Java ME套件是Java SE套件中的子集 ，它被设计出来的主要目的是提供嵌入式系统 、掌上型系统等小型操作系统的开发套件，这些系统包括了PDA、手机 、Ic卡 、家电产品和工厂自动化设备。对内存需求较小。

Android操作系统是当X行的移动端系统，它是由Java语言开发的，其运行程序均为Java。Java 的可移植性使不同手机操作系统的不同手机格式无法进行信息交流的问题得到了有效解决 。在开发安卓软件时，Java编程语言可对硬件与软件功能进行区分，建立的通讯软件系统也更完善。

互操作性是物联网应用的关键因素。Java具有很好的互操作性，因此是复杂物联网项目的X选择。Java具有多功能性和灵活性，以及跨平台性，因此物联网的开发人员一般倾向于使用Java语言进行开发。

20X，Oracle推出了Oracle Java管理服务，这是一种Oracle云基础设施（OCI）本机服务，可帮助组织在本地或任何云上管理Java运行时和应用程序。20X，Oracle公司推出Java Management Service（JMS），这是一款云端基础设施（OCI）原生服务，可协助管理内部部署或任何云端的Java程序实际执行和应用程序。 Java在Web、移动设备及云计算等方面有着前景广阔，随着云计算及移动领域的扩张，更多的企业考虑将其应用部署在Java上。

展开[a]

微型版（Micro Edition，Java ME）：Java ME同样以Java SE为基础，但相对精简。它所支持的只有核心类的子集合，它支持Java程序运行在移动终端上的平台，加入了针对移动终端的支持。这个版本2005年以前被称为J2ME。Java ME主要进行嵌入式开发，目前渐渐被Android开发所替代。

[b]

标准版 （Standard Edition，Java SE）：支持面向桌面级应用（如Windows操作系统下的应用程序）的Java平台，提供了完整的Java核心API（Application Programming Interface，应用程序接口），这个版本在2005年以前被称为J2SE。

[c]

企业版（Enterprise Edition，Java EE）：以Java SE为基础向外延伸，增加了许多支持企业内部使用的扩充类，同时支持使用多层架构的企业应用如企业资源计划 （ERP）系统、客户关系管理（CRM)）系统的应用的Java平台。除了提供Java SE API外，Java EE还对其做了大量的扩充并提供了相关的部署支持。这个版本在2005年以前被称为J2EE。

[d]

Javadoc工具解析一组Java源文件中的声明和文档注释，并生成相应的HTML页面，这些页面描述（默认情况下）公共类和受保护类、嵌套类（但不是匿名内部类）、接口、构造函数、方法和字段。用户可以使用javadoc工具为一组源文件生成API文档或实现文档。

[e]

Java现在还未使用这两个单词作为关键字，但可能在未来的Java版本中使用这两个单词作为关键字

展开[1]王维虎，刘忠，李丛. JАVA程序设计. 华中科技大学出版社, 2013.09: 1. [2022-11-03]. 978-7-5609-8498-8.

[2]李芝兴. Java程序设计之网络编程[M]. 清华大学出版社, 2006: 1-2. [2023-08-28].

[3]朱战立，沈伟. Java 程序设计实用教程[M]. 电子工业出版社, 2005-01: 1. [2023-08-28].

[4]Venners. 深入Java虚拟机[M]. 曹晓钢，蒋靖. 机械工业出版社, 2003-09: 1-124.

[5]主要功能、新功能.IntelliJ IDEA：JetBrains功能强大、符合人体工程学的Java IDE. [2022-10-30].

[6]Desktop IDE.Eclipse Desktop & Web IDEs. [2022-10-30].

[7]Java EE开发、Web开发.Myeclipse中文网官方正版. [2022-10-30].

[8]Java Downloads.Oracle. [2023-08-29].

[9]刘磊. Java应用与实战[M]. 电子工业出版社, 2023-04-01: 2-4. [2023-08-29].

[10]宋中山,，严千钧. Java程序设计[M]. 清华大学出版社, 2005: 2. [2023-08-28].

[11]胡伏湘,，雷军环. Java 程序设计实用教程[M]. 清华大学出版社, 2005: 1-6. [2023-08-28].

[12]祝X. 零基础学Java程序设计[M]. 电子工业出版社, 2021-12-01: 7. [2023-08-29].

[13]叶核亚. Java程序设计实用教程[M]. 电子工业出版社, 2019-01-01: 2-4. [2023-08-29].

[14]Java Naming Scheme.Oracle. [2023-09-06].

[15]宁跃飞，史卫亚，张洪超. Java从入门到精通[M]. 人民邮电出版社, 2022-04-01: 16-19. [2023-08-29].

[16]The Arrival of Java 20!.Inside Java. [2023-08-28].

[17]Java 软件.Oracle 中国. [2023-08-28].

[18]TIOBE index.TIOBE. [2023-08-30].

[19]Java FAQ.中国科学院科普云平台. [2023-09-18].

[20]李刚. 疯狂Java讲义[M]. 电子工业出版社, 2008-09-01: 2-760.

[21]尚硅谷教育. 剑指Java——核心原理与应用实践[M]. 电子工业出版社, 2022-06-01: 6-7. [2023-08-30].

[22]虞益诚. Java 程序设计及应用开发教程. 科学出版社, 2007: 2-4. [2023-08-28].

[23]孙鑫. Java无难事——详解Java编程核心思想与技术. 电子工业出版社, 2023-01-01: 4. [2023-08-29].

[24]刘瑜. Java从入门到项目开发实战:视频教学版[M]. 北京理工大学出版社, 2023-05-01: 2.

[25]於东军. Java程序设计与应用开发[M]. 清华大学出版社, 2005: 2-4. [2023-08-28].

[26]The javadoc Command.oracle. [2023-08-29].

[27]Java 10正式版发布：包含109项新特性（附下载地址）.闽南网. [2023-08-30].

[28]Oracle Releases Java 17.Oracle. [2023-08-30].

[29]甲骨文正式推出 Java 18.Oracle. [2023-08-30].

[30]甲骨文正式發佈Java 19.oracle. [2023-08-30].

[31]The Arrival of Java 20.Java. [2023-08-30].

[32]明日科技. Java从入门到精通[M]. 清华大学出版社, 2012-09: 46-286.

[33]Java Platform SE 8.Oracle. [2023-08-31].

[34]明日科技. Java完全自学教程[M]. 人民邮电出版社, 2022-02-01: 1-5.

[35]Welcome to Apache Maven.Maven. [2023-09-07].

[36]Introduction.Maven. [2023-09-07].

[37]Feature Summary.Maven. [2023-09-07].

[38]Gradle User Manual.Gradle. [2023-09-07].

[39]Cay S.Horstmann. Java核心技术卷II 高级特性[M]. 陈昊鹏. 机械工业出版社, 2020-05: 417.

[40]X志. 嵌入式系统综述及Java应用程序设计[J]. 电脑学习, 2005-02

[41]朱金波. Java编程语言在计算机软件开发中的应用优势分析[J]. 信息记录材料, 2023-05