Java程序设计基础
Java标识符和关键字
标识符
Java 中标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。在 Java 语言中，标识符的构成规则如下。
| 标识符由数字（0~9）和字母（A~Z 和 a~z）、美元符号（$）、下划线（_）以及 Unicode 字符集中符号大于 0xC0 的所有符号组合构成（各符号之间没有空格）。 |
| 标识符的第一个符号为字母、下划线和美元符号，后面可以是任何字母、数字、美元符号或下划线。 |
| 另外，Java 区分大小写，因此 myvar 和 MyVar 是两个不同的标识符。 |
提示：标识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，而且不能赋予标识符任何标准的方法名。
标识符分为两类，分别为关键字和用户自定义标识符。
| 关键字是有特殊含义的标识符，如 true、false 表示逻辑的真假。 |
| 用户自定义标识符是由用户按标识符构成规则生成的非保留字的标识符，如 abc 就是一个标识符。 |
提示：使用标识符时一定要注意，或者使用关键字，或者使用自定义的非关键字标识符。此外，标识符可以包含关键字，但不能与关键字重名。
标识符用来命名常量、变量、类和类的对象等。
关键字
关键字（或者保留字）是对编译器有特殊意义的固定单词，不能在程序中做其他目的使用。关键字具有专门的意义和用途，和自定义的标识符不同，不能当作一般的标识符来使用。
Java 的关键字对 Java 编译器有特殊的意义，它们用来表示一种数据类型，或者表示程序的结构等。保留字是为 Java 预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
Java 语言目前定义了 51 个关键字，这些关键字不能作为变量名、类名和方法名来使用。以下对这些关键字进行了分类。
| 数据类型 | boolean、int、long、short、byte、float、double、char、class、interface。 |
| 流程控制 | if、else、do、while、for、switch、case、default、break、continue、return、try、catch、finally。 |
| 修饰符 | public、protected、private、final、void、static、strict、abstract、transient、synchronized、volatile、native。 |
| 动作 | package、import、throw、throws、extends、implements、this、supper、instanceof、new。 |
| 保留字 | true、false、null、goto、const。 |
Java注释：单行、多行和文档注释
注释是对程序语言的说明，有助于开发者和用户之间的交流，方便理解程序。注释不是编程语句，因此被编译器忽略。
Java 支持以下三种注释方式
| 单行注释 | 以双斜杠“//”标识，只能注释一行内容，用在注释信息内容少的地方。 |
| 多行注释 | 包含在“/*”和“*/”之间，能注释很多行的内容。 |
| 文档注释 | 包含在“/**”和“*/”之间，也能注释多行内容，一般用在类、方法和变量上面，用来描述其作用。 |
Java常量
Java常量的定义和分类
常量是指在程序的整个运行过程中值保持不变的量。在这里要注意常量和常量值是不同的概念，常量值是常量的具体和直观的表现形式，常量是形式化的表现。通常在程序中既可以直接使用常量值，也可以使用常量。
常量值
常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。
整型常量值
整型（int）常量默认在内存中占 32 位，是具有整数类型的值，当运算过程中所需值超过 32 位长度时，可以把它表示为长整型（long）数值。它在内存中占 64 位。
实型常量值
Java 的实型常量值主要有如下两种形式。
| 十进制数形式：由数字和小数点组成，且必须有小数点，如 12.34、-98.0。 |
| 科学记数法形式：如 1.75e5 或 32&E3，其中 e 或 E 之前必须有数字，且 e 或 E 之后的数字必须为整数。 |
Java 实型常量默认在内存中占 64 位，是具有双精度型（double）的值。如果考虑到需要节省运行时的系统资源，而运算时的数据值取值范围并不大且运算精度要求不太高的情况，可以把它表示为单精度型（float）的数值。单精度型数值一般要在该常数后面加 F 或 f，如 69.7f，表示一个 float 型实数，它在内存中占 32 位（取决于系统的版本高低）。
布尔型常量值
Java 的布尔型常量只有两个值，即 false（假）和 true（真）。
字符型和字符串常量值
Java 的字符型常量值是用单引号引起来的一个字符.
双引号用来表示字符串。
定义常量
常量不同于常量值，它可以在程序中用符号来代替常量值使用，因此在使用前必须先定义。即在声明常量的同时要赋予一个初始值。常量一旦初始化就不可以被修改。它的声明格式为：
final dataType variableName = value常量有三种类型：静态常量、成员常量和局部常量。
在定义常量时，需要注意如下内容：
| 在定义常量时就需要对该常量进行初始化。 |
| final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。 |
| 为了与变量区别，常量取名一般都用大写字符。 |
Java变量的声明和初始化
Java 语言是强类型（Strongly Typed）语言，强类型包含以下两方面的含义：
| 所有的变量必须先声明、后使用。 |
| 指定类型的变量只能接受类型与之匹配的值。 |
这意味着每个变量和每个表达式都有一个在编译时就确定的类型。类型限制了一个变量能被赋的值，限制了一个表达式可以产生的值，限制了在这些值上可以进行的操作，并确定了这些操作的含义。
常量和变量是 Java 程序中最基础的两个元素。常量的值是不能被修改的，而变量的值在程序运行期间可以被修改。
声明变量
在 java 中用户可以通过指定数据类型和标识符来声明变量，其基本语法如下所示：
DataType identifier; 或者 DataType identifier=value;变量赋值
初始化变量是指为变量指定一个明确的初始值。初始化变量有两种方式：一种是声明时直接赋值，一种是先声明、后赋值。如下代码分别使用两种方式对变量进行了初始化。
另外，多个同类型的变量可以同时定义或者初始化，但是多个变量中间要使用逗号分隔，声明结束时用分号分隔。
Java变量的作用域：静态变量、全局变量和局部变量。
变量的作用域规定了变量所能使用的范围，只有在作用域范围内变量才能被使用。
根据作用域的不同，一般将变量分为不同的类型：成员变量和局部变量。
成员变量
Java 的成员变量有两种，分别是全局变量和静态变量（类变量）。定义在方法体和语句块之外，不属于任何一个方法，作用域是整个类。
| 名称 | 修饰 | 访问 | 生命周期 |
| 全局变量（实例变量） | 无 static 修饰 | 对象名.变量名 | 只要对象被当作引用，实例变量就将存在 |
| 静态变量（类变量） | 用 static 修饰 | 类名.变量名或对象名.变量名 | 其生命周期取决于类的生命周期。类被垃圾回收机制彻底回收时才会被销毁 |
局部变量
局部变量是指在方法或方法代码块中定义的变量，其作用域是其所在的代码块。分为三种
| 方法参数变量（形参） | 在整个方法内有效。 |
| 方法局部变量（方法内定义） | 从定义这个变量开始到方法结束这一段时间内有效。 |
| 代码块局部变量（代码块内定义） | 从定义这个变量开始到代码块结束这一段时间内有效。 |
Java数据类型
基本数据类型和引用数据类型
Java 语言支持的数据类型分为两种：基本数据类型（Primitive Type）和引用数据类型（Reference Type）。
Java基本数据类型：
| 类型名称 | 关键字 | 占用内存 | 取值范围 |
| 字节型 | byte | 1 字节 | -128~127 |
| 短整型 | short | 2 字节 | -32768~32767 |
| 整型 | int | 4 字节 | -2147483648~2147483647 |
| 长整型 | long | 8 字节 | -9223372036854775808L~9223372036854775807L |
| 单精度浮点型 | float | 4 字节 | +/-3.4E+38F（6~7 个有效位） |
| 双精度浮点型 | double | 8 字节 | +/-1.8E+308 (15 个有效位） |
| 字符型 | char | 2 字节 | ISO 单一字符集 |
| 布尔型 | boolean | 1 字节 | true 或 false |
Java 是一种强制类型的语言，所有的变量都必须先明确定义其数据类型，然后才能使用。Java 中所有的变量、表达式和值都必须有自己的类型，没有“无类型”变量这样的概念。
基本数据类型又可分为 4 大类，即整数类型（包括 byte、short，int 和 long）、浮点类型（包括 float 和 double）、布尔类型和字符类型（char），下面分别介绍这 4 大类数据类型。
| 名称 | 说明 |
| 字节型(byte) | byte 类型是最小的整数类型。当用户从网络或文件中处理数据流时，或者处理可能与 Java 的其他内置类型不直接兼容的未加工的二进制数据时，该类型非常有用。 |
| 短整(short) | short 类型限制数据的存储为先高字节，后低字节，这样在某些机器中会出错，因此该类型很少被使用。 |
| 整型(int) | int 类型是最常使用的一种整数类型。 |
| 长整型(long) | 对于大型程序常会遇到很大的整数，当超出int类型所表示的范围时就要使用long类型。 |
Java引用数据类型
引用数据类型建立在基本数据类型的基础上，包括数组、类和接口。引用数据类型是由用户自定义，用来限制其他数据的类型。
引用类型还有一种特殊的 null 类型。所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。实际上，引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法。
Java数据类型转换
强制类型转换+自动类型转换:
数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型转换成另一种数据类型。数据类型的转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。
隐式转换（自动类型转换）:
当以下 2 个条件都满足，那么将一种类型的数据赋给另外一种类型变量的时，将执行自动类型转换（automatic type conversion）。
| 两种数据类型彼此兼容。 |
| 目标类型的取值范围大于源数据类型（低级类型数据转换成高级类型数据）。 |
在运算过程中，由于不同的数据类型会转换成同一种数据类型，所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。转换规则如下：
| 数值型数据的转换：byte→short→int→long→float→double。 |
| 字符型转换为整型：char→int。 |
显式转换（强制类型转换）：
当两种数据类型不兼容，或目标类型的取值范围小于源类型时，自动转换将无法进行，这时就需要进行强制类型转换。其语法格式如下：
(type)variableNameJava算术运算符
Java 语言中的运算符除了具有优先级之外，还有一个结合性的特点。当一个表达式中出现多种运算符时，执行的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的约束，以便确定是自左向右进行运算还是自右向左进行运算。这些运算符按照操作数的数量可以分为单目运算符、双目运算符和三目运算符。
Java 中的算术运算符主要用来组织数值类型数据的算术运算，按照参加运算的操作数的不同可以分为一元运算符和二元运算符。
一元运算符
算术一元运算一共有 3 个，分别是 -、++ 和 --。
| 运 算 符 | 名 称 | 说 明 | 例 子 |
| - | 取反符号 | 取反运算 | b=-a |
| ++ | 自加一 | 先取值再加一，或先加一再取值 | a++ 或 ++a |
| -- | 自减一 | 先取值再减一，或先减一再取值 | a-- 或 --a |
二元运算符
Java 语言中算术运算符的功能是进行算术运算，除了经常使用的加（+）、减（-）、乘（*）和除（\）外，还有取模运算（％）。加（+）、减（-）、乘（*）、除（\）和我们平常接触的数学运算具有相同的含义。
| 运 算 符 | 名 称 | 说 明 | 例 子 |
| + | 加 | 求 a 加 b 的和，还可用于 String 类型，进行字符串连接操作 | a + b |
| - | 减 | 求 a 减 b 的差 | a - b |
| * | 乘 | 求 a 乘以 b 的积 | a * b |
| / | 除 | 求 a 除以 b 的商 | a / b |
| % | 取余 | 求 a 除以 b 的余数 | a % b |
算术赋值运算符
算术赋值运算符只是一种简写，一般用于变量自身的变化，具体说明参见下表。
| 运 算 符 | 名 称 | 例 子 |
| += | 加赋值 | a += b、a += b+3 |
| -= | 减赋值 | a -= b |
| *= | 乘赋值 | a *= b |
| /= | 除赋值 | a /= b |
| %= | 取余赋值 | a %= b |
Java赋值运算符（=）
赋值运算符是指为变量或常量指定数值的符号。赋值运算符的符号为“=”，它是双目运算符，左边的操作数必须是变量，不能是常量或表达式。
其语法格式如下所示：
变量名称=表达式内容在Java语言中，“变量名称”和“表达式”内容的类型必须匹配，如果类型不匹配则需要自动转化为对应的类型。
赋值运算符的优先级低于算术运算符，结合方向是自右向左；不是数学中的等号，它表示一个动作，即将其右侧的值送到左侧的变量中（左侧只允许是变量，不能是表达式或其他形式）；不要将赋值运算符与相等运算符“==”混淆。
赋值运算符与其他运算符一起使用，可以表达多种赋值运算的变异效果
| 运算符 | 含义 | 实例 | 结果 |
| += | 将该运算符左边的数值加上右边的数值， 其结果赋值给左边变量本身 | int a=5; a+=2; | a=7 |
| -= | 将该运算符左边的数值减去右边的数值， 其结果赋值给左边变量本身 | int a=5; a-=2; | a=3 |
| *= | 将该运算符左边的数值乘以右边的数值， 其结果赋值给左边变量本身 | int a=5; a*=2; | a=10 |
| /= | 将该运算符左边的数值整除右边的数值， 其结果赋值给左边变量本身 | int a=5; a/=2; | a=2 |
| %= | 将该运算符左边的数值除以右边的数值后取余，其结果赋值给左边变量本身 | int a=5; a%=2; | a=1 |
Java逻辑运算符（&&、||和!）
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。
逻辑运算符是对布尔型变量进行运算，其结果也是布尔型。
| 运算符 | 用法 | 含义 | 说明 | 实例 | 结果 |
| && | a&&b | 短路与 | ab 全为 true 时，计算结果为 true，否则为 false。 | 2>1&&3<4 | true |
| || | a||b | 短路或 | ab 全为 false 时，计算结果为 false，否则为 true。 | 2<1||3>4 | false |
| ! | !a | 逻辑非 | a 为 true 时，值为 false，a 为 false 时，值为 true | !(2>4) | true |
| | | a|b | 逻辑或 | ab 全为 false 时，计算结果为 false，否则为 true | 1>2|3>5 | false |
| & | a&b | 逻辑与 | ab 全为 true 时，计算结果为 true，否则为 false | 1<2&3<5 | true |
| && 与 & 区别 | 如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false） | ||||
| || 与 | 区别 | 如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true） | ||||
注意：短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
| a | b | a&&b | a||b | !a |
| true | true | true | true | false |
| false | true | false | true | true |
| true | false | false | true | false |
| false | false | false | false | true |
逻辑运算符的优先级为：！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。结合方向是：逻辑非（单目运算符）具有右结合性，逻辑与和逻辑或（双目运算符）具有左结合性。
Java关系运算符
关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。
关系表达式是由关系运算符连接起来的表达式。关系运算符中“关系”二字的含义是指一个数据与另一个数据之间的关系，这种关系只有成立与不成立两种可能情况，可以用逻辑值来表示，逻辑上的 true 与 false 用数字 1 与 0 来表示。关系成立时表达式的结果为 true（或 1），否则表达式的结果为 false（或 0）。
| 运算符 | 含义 | 说明 | 实例 | 结果 |
| > | 大于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值大于后面变量的值， 则返回 true。 | 2>3 | false |
| >= | 大于或等于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值大于等于后面变量的值， 则返回 true。 | 4>=2 | true |
| < | 小于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值小于后面变量的值，则返回 true。 | 2<3 | true |
| <= | 小于或等于运算符 | 只支持左右两边操作数是数值类型。如果前面变量的值小于等于后面变量的值， 则返回 true。 | 4<=2 | false |
| == | 相等运算符 | 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 Java也支持两个 boolean 类型的值进行比较。 | 4==4 97=='a' 5.0==5 true==false | true true true false |
| != | 不相等运算符 | 如果进行比较的两个操作数都是数值类型，无论它们的数据类型是否相同，只要它们的值不相等，也都将返回 true。 如果两个操作数都是引用类型，只有当两个引用变量的类型具有父子关系时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。 | 4!=2 | true |
注意点如下所示
| 基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较；boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较；如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较。 |
| == 和 != 可以应用于基本数据类型和引用类型。当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象。 |
关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。
关系表达式通常用于 Java 程序的逻辑判断语句的条件表达式中。使用关系表达式要注意：
| 运算符 >=、==、！=、<= 是两个字符构成的一个运算符，用空格从中分开写就会产生语法错误。例如 x> =y; 是错误的，但是可以写成x >= y; 在运算符的两侧增加空格会提高可读性。同样将运算符写反，例如 =>、=<、=! 等形式会产生语法错误。 |
| 由于计算机内存放的实数与实际的实数存在着一定的误差，如果对浮点数进行 ==（相等）或 !=（不相等）的比较，容易产生错误结果，应该尽量避免。 |
| 不要将“==”写成“=”。 |
Java自增和自减运算符（++和--）
在对一个变量做加 1 或减 1 处理时，可以使用自增运算符 ++ 或自减运算 --。++ 或 -- 是单目运算符，放在操作数的前面或后面都是允许的。++ 与 -- 的作用是使变量的值增 1 或减 1。操作数必须是一个整型或浮点型变量。自增、自减运算的含义及其使用。
| 运算符 | 含义 | 实例 | 结果 |
| i++ | 将 i 的值先使用再加 1 赋值给 i 变量本身 | int i=1; int j=i++; | i=2； j=1 |
| ++i | 将 i 的值先加 1 赋值给变量 i 本身后再使用 | int i=1; int j=++i; | i=2；j=2 |
| i-- | 将 i 的值先使用再减 1 赋值给变量 i 本身 | int i=1; int j=i--; | i=0；j=1 |
| --i | 将 i 的值先减 1 后赋值给变量 i 本身再使用 | int i=1;int j=--i; | i=0；j=0 |
在使用自增/自减运算时应注意。
| 自增/自减只能作用于变量，不允许对常量、表达式或其他类型的变量进行操作。常见的错误是试图将自增或自减运算符用于非简单变量表达式中。 |
| 自增/自减运算可以用于整数类型 byte、short、int、long，浮点类型 float、double，以及字符串类型 char。 |
| 在 Java1.5 以上版本中，自增/自减运算可以用于基本类型对应的包装器类 Byte、Short、Integer、Long、Float、Double 和 Character。 |
| 自增/自减运算结果的类型与被运算的变量类型相同。 |
Java位运算符：Java移位运算符、复合位赋值运算符及位逻辑运算符
Java 定义的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括 long，int，short，char 和 byte。
位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。
Java 语言中的位运算符分为位逻辑运算符和位移运算符两类。
位逻辑运算符
位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。表 1 中列出了它们的基本用法。
| 运算符 | 含义 | 实例 | 结果 |
| & | 按位进行与运算（AND） | 4 & 5 | 4 |
| | | 按位进行或运算（OR） | 4 | 5 | 5 |
| ^ | 按位进行异或运算（XOR） | 4 ^ 5 | 1 |
| ~ | 按位进行取反运算（NOT） | ~ 4 | -5 |
位与运算符
位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为1，那么计算结果才为1，否则为 0。因此，任何数与0进行按位与运算，其结果都为 0。
位或运算符
位或运算符为|，其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。
位异或运算符
位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。
提示：在有的高级语言中，将运算符^作为求幂运算符，要注意区分。
位取反运算符
位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。
注意：位运算符的操作数只能是整型或者字符型数据以及它们的变体，不用于 float、double 或者 long 等复杂的数据类型。
位移运算符
位移运算符用来将操作数向某个方向（向左或者右）移动指定的二进制位数。下面列出了 Java 语言中的两个位移运算符，它们都属于双目运算符。
| 运算符 | 含义 | 实例 | 结果 |
| » | 右移位运算符 | 8»1 | 4 |
| « | 左移位运算符 | 9«2 | 36 |
左位移运算符
左移位运算符为«，其运算规则是：按二进制形式把所有的数字向左移动对应的位数，高位移出（舍弃），低位的空位补零。
右位移运算符
右位移运算符为»，其运算规则是：按二进制形式把所有的数字向右移动对应的位数，低位移出（舍弃），高位的空位补零。
复合位赋值运算符
所有的二进制位运算符都有一种将赋值与位运算组合在一起的简写形式。复合位赋值运算符由赋值运算符与位逻辑运算符和位移运算符组合而成。下表列出了组合后的复合位赋值运算符。
| 运算符 | 含义 | 实例 | 结果 |
| &= | 按位与赋值 | num1 &= num2 | 等价于 num 1=num 1 & num2 |
| |= | 按位或赋值 | num1 |= num2 | 等价于 num 1=num 1 | num2 |
| ^= | 按位异或赋值 | num1 ^= num2 | 等价于 num 1=num 1 ^ num2 |
| -= | 按位取反赋值 | num1 ~= num2 | 等价于 num 1=num 1 ~ num2 |
| «= | 按位左移赋值 | num1 «= num2 | 等价于 num 1=num 1 « num2 |
| »= | 按位右移赋值 | num1 »= num2 | 等价于 num 1=num 1 » num2 |
Java三目运算符（条件运算符? :）
Java 提供了一个特别的三元运算符（也叫三目运算符）经常用于取代某个类型的 if-then-else 语句。条件运算符的符号表示为“?:”，使用该运算符时需要有三个操作数，因此称其为三目运算符。使用条件运算符的一般语法结构为：
result = <expression> ? <statement1> : <statement3>;其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。
技巧：可以将条件运算符理解为 if-else 语句的简化形式，在使用较为简单的表达式时，使用该运算符能够简化程序代码，使程序更加易读。
在使用条件运算符时，还应该注意优先级问题。
Java运算符优先级
所有的数学运算都认为是从左向右运算的，Java语言中大部分运算符也是从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。
乘法和加法是两个可结合的运算，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。运算符有不同的优先级，所谓优先级就是在表达式运算中的运算顺序。
一般而言，单目运算符优先级较高，赋值运算符优先级较低。算术运算符优先级较高，关系和逻辑运算符优先级较低。多数运算符具有左结合性，单目运算符、三目运算符、赋值运算符具有右结合性。
Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。下表列出了所有的运算符的优先级以及结合性。
| 优先级 | 运算符 | 结合性 |
| 1 | ()、[]、{} | 从左向右 |
| 2 | !、+、-、~、++、-- | 从右向左 |
| 3 | *、/、% | 从左向右 |
| 4 | +、- | 从左向右 |
| 5 | «、»、>>> | 从左向右 |
| 6 | <、<=、>、>=、instanceof | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | | | 从左向右 |
| 11 | && | 从左向右 |
| 12 | || | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>= | 从右向左 |
使用优先级为 1 的小括号可以改变其他运算符的优先级，即如果需要将具有较低优先级的运算符先运算，则可以使用小括号将该运算符和操作符括起来。
Java直接量（字面量）
直接量是指在程序中通过源代码直接给出的值，例如在int a = 5;代码中，为变量 a 所分配的初始值 5 就是一个直接量。
直接量的类型
并不是所有的数据类型都可以指定直接量，能指定直接量的通常只有三种类型：基本类型、字符串类型和 null 类型。具体而言，Java支持如下 8 种类型的直接量。
| int 类型的直接量 | 在程序中直接给出的整型数值，可分为二进制、十进制、八进制和十六进制 4 种。 |
| long 类型的直接量 | 在整型数值后添加 l 或 L 后就变成了 long 类型的直接量。 |
| float 类型的直接量 | 在一个浮点数后添加 f 或 F 就变成了 float 类型的直接量，这个浮点数可以是标准小数形式，也可以是科学计数法形式。 |
| double 类型的直接量 | 直接给出一个标准小数形式或者科学计数法形式的浮点数就是 double 类型的直接量。 |
| boolean 类型的直接量 | 这个类型的直接量只有 true 和 false。 |
| char 类型的直接量 | char 类型的直接量有三种形式，分别是用单引号括起来的字符、转义字符和 Unicode 值表示的字符。 |
| String 类型的直接量 | 一个用双引号括起来的字符序列就是 String 类型的直接量。 |
| null 类型的直接量 | 这个类型的直接量只有一个值，即 null。 |
在上面的 8 种类型的直接量中，null 类型是一种特殊类型，它只有一个值：null。而且这个直接量可以赋给任何引用类型的变量，用以表示这个引用类型变量中保存的地址为空，即还未指向任何有效对象。
直接量的赋值
通常总是把一个直接量赋值给对应类型的变量。
除此之外，Java 还支持数值之间的自动类型转换，因此允许把一个数值直接量直接赋给另一种类型的变量，这种赋值必须是系统所支持的自动类型转换，例如把 int 类型的直接量赋给一个 long 类型的变量。
String 类型的直接量不能赋给其他类型的变量，null 类型的直接量可以直接赋给任何引用类型的变量，包括 String 类型。boolean 类型的直接量只能赋给 boolean 类型的变量，不能赋给其他任何类型的变量。
关于字符串直接量有一点需要指出，当程序第一次使用某个字符串直接量时，Java 会使用常量池（constant pool）来缓存该字符串直接量，如果程序后面的部分需要用到该字符串直接量时，Java 会直接使用常量池（constantpool）中的字符串直接量。
提示：
| 由于 String 类是一个典型的不可变类，因此 String 对象创建出来的就不可能改变，因此无需担心共享 String 对象会导致混乱。 |
| 常量池（constant pool）指的是在编译期被确定，并被保存在已编译的 .class 文件中的一些数据，它包括关于类、方法、接口中的常量，也包括字符串直接量。 |
Java 会确保每个字符串常量只有一个，不会产生多个副本。
