第 章 程序由语句组成, 语句经常使用数据类型 运算符 表达式等 Java 语言的数据类型 运算符与表达式等是从 C++ 语言简化而来, 更加简洁 高效 2. 1 常量和变量 Java 程序运行时, 值不可修改的数据称为常量, 分为字面常量 ( 常数 ) 与标识符常量两种 变量是程序运行时值发生改变

第 章 程序由语句组成, 语句经常使用数据类型 运算符 表达式等 Java 语言的数据类型 运算符与表达式等是从 C++ 语言简化而来, 更加简洁 高效 2. 1 常量和变量 Java 程序运行时, 值不可修改的数据称为常量, 分为字面常量 ( 常数 ) 与标识符常量两种 变量是程序运行时值发生改变的量 2.1.1 数据类型 Java 是一种强类型语言, 这意味着所有变量都必须先明确定义其数据类型才能使用 Java 语言的数据类型有两类 : 基本数据类型与引用类型 基本数据类型包括 :boolean( 布尔型 ) byte( 字节型 ) short( 短整型 ) int( 整型 ) long( 长整型 ) char( 字符型 ) float( 单精度浮点型 ) 和 double( 双精度浮点型 ) 共 8 种 其余为引用类型, 例如数组 字符串 类 接口 用户自定义类型等 所有基本数据类型的大小 ( 所占用的字节数 ) 都有明确规定, 在各种不同平台上保持一致, 这点有助于提高 Java 程序的可移植性 各基本数据类型的大小及取值范围, 如表 2.1 所示 表 2.1 基本数据类型的大小及取值范围 数据类型 关键字 在内存占用的字节数 取值范围 默认值 布尔型 boolean 1 个字节 (8 位 ) true false false 字节型 byte 1 个字节 (8 位 ) -128~127 (byte)0 短整型 short 2 个字节 (16 位 ) -215~215-1 (short)0 整型 int 4 个字节 (32 位 ) -231~231-1 0 长整型 long 8 个字节 (64 位 ) -263~263-1 0L 字符型 char 2 个字节 (16 位 ) \u0000 ~ \uffff \u0000 单精度浮点型 float 4 个字节 (32 位 ) 双精度浮点型 double 8 个字节 (64 位 ) -3.4028E+38~-1.4013E-45 和 1.4013E-45~3.4028E+38-1.7977E+308~-4.9E-324 和 4.9E-324~1.7977E+308 0.0F 0.0D 2.1.2 标识符和关键字 标识符是指程序中包 类 接口 变量或方法名字的字符序列 Java 语言要求标识符必须符合以下命名规则 标识符由数字 (0~9) 大写字母(A~Z) 小写字母(a~z) 下画线 _ 以及美元符号 $ 等组成, 并且长度不受限制

14 Java 实用教程 ( 第 3 版 ) 标识符的首字符必须是字母 下画线 _ 或美元符号 $ 不能把关键字和保留字作为标识符 标识符是大小写敏感的, 例如,hello 与 Hello 是两个不同的标识符 表 2.2 是一个标识符正误对照表, 列举了一些合法的标识符和非法的标识符 表 2.2 标识符正误对照表 合法的标识符 非法的标识符 说 明 HelloWorld class 不能用关键字做标识符 _123 12.3b 标识符不能以数字开头 $a123 Hello World 标识符中不能含有空格 Subject Subject# 标识符中不能含有 # 在命名 Java 标识符时, 应做到 见名知意 Java 中一些被赋予特定含义 用作专门用途的字符序列称为关键字, 包括 : 数据类型 :boolean byte short int long char float double 包引入和声明 :import package 类和接口声明 :class extends implements interface 流程控制 :if else switch do while case break continue return default while for 异常处理 :try catch finally throw throws 修饰符 :abstract final native private protected public static synchronized transient volatile 其他 :new instanceof this super void assert const* enum goto* strictfp 注意 : 打上 * 的关键字,Java 没有使用 2.1.3 常量 Java 程序运行时值不可修改的量称为常量, 分为字面量 ( 常数 ) 与标识符常量两种 字面量即 Java 源程序中表示的常数值, 如 12.6 123 0x12 false "hello" 等, 表示一个个具体的值, 它是有类型的, 有如下 5 种 1. 布尔型常量 (boolean) 布尔型常量值只有 true 或 false, 它们也可看成是 Java 语言的关键字, 不能挪作他用且必须小写 true 表示 逻辑真,false 表示 逻辑假 注意 : 不能认为 非零值或 1 是 true 零值 是 false 2. 整型常量 (int 或 long) 整型常量有十进制 八进制 十六进制三种表示法 (1) 十进制 : 十进制整数, 如 123-48 等 (2) 八进制 : 以数字 0 开头的八进制整数, 如 017-021 等 (3) 十六进制 : 以 0x 或 0X 开头的十六进制整数, 如 0x12a6 0XAB12-0x1a0 等 整型常量 (int) 在机器中占 32 位 (4 个字节 ), 故最大的整型常量是 2147483647( 该值由 Integer.MAX_VALUE 表示 ); 最小的整型常量是 -2147483648( 由 Integer.MIN_VALUE 表示 ) 若程序

第 2 章 Java 语法基础 15 中出现一个整型常量其值超出上述范围, 就会产生一个编译错误 为避免该错误, 要在该值后加上 L 或 l, 使它成为一个 long 型常量 最大的长整型常量值由 Long.MAX_VALUE 表示, 最小的长整型常量值由 Long.MIN_VALUE 表示 若要表示 long 型常量值, 就在整数值后加上 L 或 l, 该类型常量占 64 位, 如 20000L 若要表示 byte 或 short 型的常量值, 通常用强制类型转换, 例如,(byte)0x12a6 (short)2147483640 等 3. 浮点型常量 (float 或 double) 浮点型常量有两种表示形式 : 十进制小数形式和科学记数法形式 (1) 十进制小数形式 : 小数点两边的数字不能同时省略且小数点不能省略 合法的 double 型浮点数如 3.14 1.0 注意 : 1.0 是 double 类型常量值, 而 1 是 int 类型常量值,1.0f 才是 float 类型的常量值, 在内存中占用字节数以及表示的格式是不同的 (2) 科学记数法形式 : 如 1.26 10-21 在 Java 中表示为 1.26e-21 或 1.26E-21, 这是一个 double 型的浮点数 E 或 e 的前面必须有数字且 E 或 e 后边必须是一个正 / 负整数 ( 正号可省略 ) 由于 E 或 e 的后边必须是一个整数, 那么 1.26 10-2.65 该如何表示? 可用 java.lang.math 类中的方法 pow(), 表示为 : Math.pow(1.26,-2.65) 数值后边加上 d 或 D 表示是 double 型的浮点数, 在机器中占 64 位 只有在数值后边加上 F 或 f 才表示是 float 型的浮点数 ( 机器中占 32 位 ), 例如,12.34f 3.14f 等, 其有效精度是 6 位, 这在表示较大数值时精度不够, 故 Java 语言将默认的浮点数精度规定为 double 型 4. 字符型常量 (char) Java 中的字符采用 Unicode 字符集的编码方案, 是 16 位的无符号整数, 占 2 个字节, 表示的字符从 0~65535 字符型常量值有两种表示方法 (1) 对于可输入字符, 用单引号将字符括起来, 如,'a' ' 啊 ' 等 (2) 对于不可输入字符, 常采用转义字符表示 '\n' 表示换行, 其 Unicode 值是 10 '\r' 表示回车, 其 Unicode 值是 13 '\t' 表示 Tab 键, 其 Unicode 值是 9 '\ddd' 表示用 3 位八进制数代表的 ASCII 字符, 从 '\000'~'\377', 可表示 256 个 ASCII 字符 '\uxxxx' 表示用 4 位十六进制数代表 Unicode 字符, 从 '\u0000'~ '\uffff', 可表示所有的 Unicode 字符, 其中的 u 可以任意多个连续, 例如,'\uuuu5de5' 与 '\u5de5' 相同 '\'' 表示字符 ', 即 '\u0027' '\"' 表示字符 ", 即 '\u0022' '\\' 表示字符 \, 即 '\u005c' 例如, 字符串 "a 汉 b\u0067t\067\'\"\\ 字 " 表示 a 汉 bgt7'"\ 字 注意 : Java 中 Unicode 转义字符序列的处理时机 编译时, 编译程序首先将组成源程序的原始的 Unicode 字符流进行 Unicode 转义字符序列处理变成 Unicode 流, 然后再进行编译处理 故下边的换行用法不正确 ( 企图用 \u000a 代替 \n): String s = "abc\u000adef"; 编译程序会报错 :unclosed string literal 正确用法应该是:String s = "abc\ndef"; 5. 字符串常量 (String) Java 中字符串实际上是字符串类 java.lang.string 的一个对象, 所有字符串常量值都用双引号括起来, 如 "abc" 由于"abc" 是一个对象, 故它可以使用类 String 中的方法, 如 "a 汉 b 字 c".length() 返回该串的长度 5, 而 "a 汉 b 字 c".charat(3) 返回下标值 3 所对应的字符 :' 字 '( 下标值的起点从 0 开始 )

16 Java 实用教程 ( 第 3 版 ) 注意 : null 可以简单看成是一个引用类型的常量值, 表示不引用任何对象 在 Java 规范中, 规定 null 是所谓 null 类型的唯一值, 且规定 null 可转换到任何引用类型 除了上面介绍的字面量常量外,Java 中主要的常量是标识符常量 一个标识符常量实际上是一个 变量, 但它的值一旦初始化以后就不允许再发生改变, 因此标识符常量要先定义后使用, 通常用于给 一个常数取个有意义的名字 标识符常量可以是任何类型, 其定义格式是在变量定义的前面加上 final 保留字, 如 例 1.1 中定义了一个 double 型常量 PI:final double PI = 3.1416; 按 Java 编码规范, 常量名通常用大写表示, 若常量名由两个或以上单词组成, 则单词间用下画线 连接, 例如,final int MAX_VALUE = 100; 2.1.4 变量 与常量不同, 变量是程序运行时值会发生改变的量, 它对应着内存空间中一个或几个单元, 变量 的值就存放在这些内存单元中 变量名实质就是给它对应的内存单元取的一个有意义的名称, 这样在 程序中, 就可以按变量名来区分和使用这些内存单元 1.boolean 类型 boolean 类型的变量取值只能是 true 或 false 在 JVM 内部, 用 int 或 byte 类型来表示 boolean, 用 整数零表示 false, 用任意一个非零整数来表示 true 只不过这些对程序员是透明的 2.byte short int 和 long 类型 byte short int 和 long 都是整数类型, 并且都是有符号整数 在定义这 4 种类型的整型变量时, Java 编译器给它们分配的内存空间大小是不同的 byte 类型占用的内存空间最小 (1 个字节 ),long 类 型占用的内存空间最大 (8 个字节 ) 如果一个整数值在某种整数类型的取值范围内, 就可以把它直接 赋给该类型的变量, 否则必须进行强制类型转换 例如, 整数 13 在 byte 类型的取值范围 (-128~127) 内, 可以把它直接赋给 byte 类型变量 ;129 不在 byte 类型的取值范围内, 若想赋值, 就必须进行强制 类型转换, 语句如下 : byte b = (byte)129 // 变量 b 的取值为 -127 这句代码中的 (byte) 表示把 129 强制转换为 byte 类型,129 的二进制数据形式为 :0000 0000 0000 0000 0000 0000 1000 0001 (byte) 运算符截取后 8 位为 1000 0001, 故其值为 -127 如果在整数后面加上后缀 L 或 l, 就表示它是一个 long 类型整数 3.char 类型与字符编码 char 是字符类型,Java 语言对字符采用 Unicode 编码, 这是一种双字节编码, 表示字符范围 \u0000 ~ \uffff 由于计算机只能存储二进制数据, 因此必须为各个字符进行编码 所谓字符编 码, 是指用一串二进制数据来表示特定的字符 Unicode 字符编码由国际 Unicode 协会编制, 收录了全 世界所有语言文字中的字符, 是一种跨平台的字符编码 4.float 和 double 类型 float 和 double 类型都遵循 IEEE754 标准, 该标准分别为 32 位和 64 位浮点数规定了二进制数据表 示形式 IEEE 754 采用二进制数据的科学记数法来表示浮点数 对于 float 浮点数, 用 1 位表示数字的 符号, 用 8 位表示指数 ( 底数为 2), 用 23 位表示尾数 对于 double 浮点数, 用 1 位表示数字的符号, 用 11 位表示指数 ( 底数为 2), 用 52 位表示尾数

第 2 章 Java 语法基础 17 2.1.5 类型转换每一个表达式都有一个类型 表达式在使用过程中, 当其所处的上下文要求的类型与表达式类型不一致时, 就会发生类型转换 常见的发生类型转换的上下文有 : 赋值时类型转换 方法调用时类型转换 强制类型转换 字符串类型转换 数值类型提升等 当上下文中要求类型转换时, 转换应遵循什么规则呢? 对于 Java 基本数据类型, 类型转换有以下 3 种 1. 宽转换所谓的宽转换又称自动类型转换或隐式转换, 转换规则如下 : (1)byte 可直接转换到 short int long float double; (2)short 可直接转换到 int long float double; (3)char 可直接转换到 int long float double; (4)int 可直接转换到 long float double; (5)long 可直接转换到 float double; (6)float 可直接转换到 double 注意 : 1 byte short int 都是有符号的数, 因而宽转换时 ( 如转换到 long) 要进行符号位扩展 char 实际上是 0~65535 的无符号数, 其符号位可认为是 0, 因而转换到 int 或 long 时, 永远是用 0( 二进制位零 ) 进行扩展, 如 int i=(char) (byte)(-1);(i 的值为 65535) 2 int 转换到 float 或 long 转换到 double, 很可能会造成精度丢失, 如 int big = 1234567891; float f = big; 此时 f 中小数点之后已不能精确表示 891 了, 即精度丢失了 2. 窄转换窄转换的转换规则如下 : (1)short 可直接转换到 byte char; (2)char 可直接转换到 byte short; (3)int 可直接转换到 byte short char; (4)long 可直接转换到 byte short char int; (5)float 可直接转换到 byte short char int long; (6)double 可直接转换到 byte short char int long float 注意 : 1 窄转换在大多数情况下会丢失信息 当 int 窄转换到 byte 时, 会丢弃掉 int 的最高 3 个字节 (24 位 ), 将最低的 1 个字节 (8 位 ) 放入 byte 中 因此, 大多数情况下窄转换要求程序员自己明确地指明 2 char 窄转换到 short, 将 char 的两个字节 (16 位 ) 直接放入到 short 中 虽然 char 与 short 都是 16 位, 但窄转换到 short 时, 其结果可能会由正数变成一个负数了 3. 宽窄同时转换宽窄同时转换发生在 byte 转换到 char 期间, 其转换过程为 : 先将 byte 宽转换到 int, 再将 int 窄转换到 char 上述所讲的基本数据类型的 3 种转换在 Java 程序中经常发生 例如, 当将一个表达式的值赋给一

18 Java 实用教程 ( 第 3 版 ) 个变量时 ( 称为赋值类型转换上下文 ), 会自动进行 宽转换 和某些特定的 窄转换 例如下面的代码片段 : byte b = 2; short s; s = ++ b; 表达式 ++b 是 byte 类型, 而 s 是 short 类型, 因而期望赋值符 = 右部出现的 short 类型 自动执行 宽转换, 将 byte 转换为 short 赋值时允许的特定的 窄转换 是 : 若常量表达式 ( 或常数 ) 的类型是 byte short char int, 要将值赋给一个变量 V( 类型是 byte short char) 若常量值处于变量 V 的数据类型范围之内, 则编译程序自动进行这种特定的 窄转换 如 byte v = \uff00, 则必须要程序员自己明确进行 窄转换 另外一种经常发生的类型转换上下文是 数值提升 当使用算术运算符(+,-,*,/,%) 关系运算符 (<,<=,>,>=,==,!=) 位运算符(&,,^,~,>>,>>>,<<) 及条件运算符 (?:) 时, 编译程序会按 宽转换 自动进行 数值提升 例如下面的代码片段: byte b = 10; long l = 20; 对于表达式 b+l, 首先将 b 宽转换 成 long, 然后按 long 进行 + 运算 结果类型是 long 型 再如 : byte b = 10; char c = \u0065 ; 对于表达式 b+c, 首先将 b 与 c 按 宽转换 自动提升为 int, 然后按 int 进行计算, 结果类型为 int 说明 : 若是在 byte short char 三者之间进行运算, 则首先将它们全部按 宽转换 自动提升为 int, 然后按 int 再进行运算 其他类型转换上下文请参见相关章节 例 2.1 Java 基本数据类型转换 TypeCast.java public class TypeCast { public static void main(string[] args){ byte b =1; // 自动类型转换 int i=b; long l=b; float f=b; double d=b; char ch='c'; int i2 = ch; // 转换为对应的 ASCII 码值 System.out.println("i2:"+i2); short s = 99; char c=(char)s; // 强制类型转换 System.out.println("c:"+c); byte b1 = (byte)129; System.out.println("b1:"+b1); 程序运行结果 :

第 2 章 Java 语法基础 19 i2: 99 c: c b1: -127 2. 2 运算符和表达式 在 Java 中, 运算符和表达式是实现数据操作的两个重要组成部分 运算符用来表示各种运算的符号, 表达式是符合一定语法规则的运算符和操作数的序列 2.2.1 运算符 Java 中表达各种运算的符号称为运算符, 运算符的运算对象称为操作数 只需要一个操作数参与运算的运算符称为单目运算符, 如 +( 正号 ) -( 负号 ) 等 ; 需要两个操作数参与运算的运算符称为双目运算符, 如 *( 乘 ) +( 加 ) 等 ; 需要三个操作数参与运算的运算符称为三目运算符, 如?:( 条件运算符 ) 表 2.3 列出了 Java 中的运算符及其相关的内容 表 2.3 Java 运算符一览表 优先级运算符类型描述目数结合性. [] 成员运算符 数组下标运算符 双目 双目 1( 最高 ) () 圆括号 从左向右 表达式 ++ 算术 后自增 1 运算符 单目 表达式 -- 算术 后自减 1 运算符 单目 ++ 表达式 算术 前自增 1 运算符 单目 -- 表达式 算术 前自减 1 运算符 单目! 逻辑 逻辑非 单目 2 ~ + 位运算 按位求反正号 单目单目 从右向左 - 负号 单目 ( 类型 ) 强制类型转换 单目 3 new( 类型 ) 内存分配运算符单目 * 算术 乘 4 / 算术 实数除或取整 % 算术 取余数 5 + - 算术加 减运算符 >> 位运算 保留符号的右移 双目 从左向右 6 >>> 位运算 不保留符号右移 << 位运算 左移 7 > >= < <= instanceof 关系 大于 大于等于 小于 小于等于实例运算符

20 Java 实用教程 ( 第 3 版 ) 续表 优先级 运算符 类 型 描 述 目 数 结合性 8 = =! = 关系 相等 不相等 9 & 位运算 位与 10 ^ 位运算 位异或 11 位运算 位或 12 && 逻辑 逻辑与 13 逻辑 逻辑或 双目 从左向右 14?: 条件运算符三目 15 -> 箭头运算符 ( 用于 lambda 表达式 ) 16( 最低 ) = += -= *= /= %= ^= &= = 赋值运算符 双目 从右向左 <<= >>= >>>= 1. 算术运算符 算术运算符用于处理整型 浮点型 字符型的数据, 进行算术运算 + 做了重载 (Java 中唯一重载的符号 ), 如 "abc" + var_a, 其中变量 var_a 可为任何 Java 类型 如 "abc" + 12.6 结果是 abc12.6, 又如 12.6 + "abc" 结果是 12.6abc 再如 int a = 10,b = 11, 则 "a + b = " + a + b 值是 a + b = 1011 而"a + b = " + (a + b) 值是 a + b = 21 / 用于整型表示取整, 如 7/2 结果为 3; 用于 float double 表示实数相除, 如 7.0/2 结果为 3.5 例如下面的语句: int a = 7,b = 2; float c; c = a / b; c 的值仍是 3.0f, 若要使 a/b 按实数除法进行, 要用强制类型转换 c = (float)a/b, 即先将 a 的类型转换成 float, 然后 / 才按实数进行相除 % 用于整型表示取余数, 如 15%2 结果为 1 (-15) % 2 结果为 -1 15 % (-2) 结果为 1 (-15) % (-2) 结果为 -1 % 用于 float double 表示实数取余, 如 15.2%5 = 0.2 ++ 表示自增, 有前自增 ( 如 ++a) 与后自增 ( 如 a++) 两种, 其中 a 必须是一个变量 ++a 表示 : 先将 a 的值增加 1, 然后 a 的值 ( 已增加 1) 即为整个表达式 (++a) 的值 a++ 表示 : 先将 a 的值 ( 未增加 ) 作为整个表达式 (a++) 的值, 然后 a 的值增加 1 -- 表示自减, 有前自减 ( 如 --a) 与后自减 ( 如 a--) 两种, 其中 a 必须是一个变量 --a 表示 : 先将 a 的值减少 1, 然后 a 的值 ( 已减少 1) 即为整个表达式 (--a) 的值 a-- 表示 : 先将 a 的值 ( 未减少 ) 作为整个表达式 (a--) 的值, 然后 a 的值减少 1 在 Java 中没有乘幂运算符 若要进行乘幂运算, 如 x y, 可用类 Math 的 pow() 方法 :Math.pow(x,y) 例 2.2 测试自增和自减运算符的作用 Test.java public class Test { public static void main(string[] args) { int i1 = 5, i2 =10; int i = (i2++); System.out.println("i="+i);

第 2 章 Java 语法基础 21 程序运行结果 : i=10 i2=11 i=12 i2=12 i=4 i1=4 i=4 i1=3 2. 关系运算符 System.out.println("i2="+i2); i=(++i2); System.out.println("i="+i); System.out.println("i2="+i2); i=(--i1); System.out.println("i="+i); System.out.println("i1="+i1); i =(i1--); System.out.println("i="+i); System.out.println("i1="+i1); 关系运算符用于比较两个操作数, 运算结果是布尔类型的值 true 或 false 所有关系运算符都是二 目运算符 Java 中共有六种关系运算符 :> >= < <=!= = = 前四种优先级相同, 且高于后面的两种, 如 a= = b> c 等效于 a = = (b > c) 在 Java 中, 任何类型的数据 ( 无论是基本数据类型还是引用类型 ) 都可以通过 = = 或!= 来比较是 否相等或不等, 如布尔类型值 true= =false 运算结果是 false 只有 char byte short int long float double 类型才能用于前四种关系运算 3. 逻辑运算符 布尔逻辑运算符用于将多个关系表达式或 true false 组成一个逻辑表达式 Java 中的逻辑运算符 有 :&( 与 ) ( 或 )!( 非 ) ^( 异或 ) &&( 短路与 ) ( 短路或 ) a && b: 只有 a 与 b 都为 true, 结果才为 true; 有一个为 false, 结果就为 false a b: 只有 a 与 b 都为 false, 结果才为 false; 有一个为 true, 结果就为 true! a: 与 a 的值相反 Java 中逻辑表达式进行所谓的 短路 计算, 如计算 a b && c 时, 若 a 的值为 true, 则右边 b && c 就不再进行计算, 最后结果一定是 true; 只有当 a 为 false 时, 右边 b && c 才有执行的机会 当进一 步计算 b && c 时, 仍是短路计算, 当 b 是 false 时,c 不用计算 ; 只有当 b 为 true 时,c 才有执行机会 Java 编译程序按短路计算方式来生成目标代码 这 3 个逻辑运算符的优先级与结合性见前表 2.3 例 2.3 测试逻辑运算符的作用

22 Java 实用教程 ( 第 3 版 ) LogicTest.java public class LogicTest { public static void main(string[] args) { boolean a,b,c; a = true; b = false; c = a & b; System.out.println(c); c = a b; System.out.println(c); c = a ^ b; System.out.println(c); c =!a; System.out.println(c); c = a && b; System.out.println(c); c = a b; System.out.println(c); 程序运行结果 : false true true false false true 4. 位运算符 位运算符是对操作数按其在计算机内部的二进制表示按位进行操作 参与运算的操作数只能是 int long 类型, 其他类型的数据要参与位运算要转换成这两种类型 Java 中共有下列 7 种位运算符 (1) 按位求反运算符 :~ ~ 是单目运算符, 对操作数的二进制数据的每一个二进制位都取反 即 1 变成 0,0 变成 1 例如, ~10010011 结果是 01101100 (2) 与运算符 :& 参与运算的两个操作数, 相应的二进制数位进行与运算 即 0 & 0 = 0,0 & 1 = 0,1 & 0 = 0,1 & 1 = 1 例如,a = 11001011, 则 a = a &11111100 的结果是 a 的值变为 11001000, 效果是前 6 位不变, 最 后 2 位清零 (3) 或运算符 : 参与运算的两个操作数, 相应的二进制数位进行或运算 即 0 0 = 0,0 1 = 1,1 0 = 1,1 1 = 1 例如,a = 11001000, 则 a = a 00000011 的结果是 a 的值变为 11001011, 效果是前 6 位不变, 最 后 2 位置 1

第 2 章 Java 语法基础 23 (4) 异或运算符 :^ 参与运算的两个操作数, 相应的二进制数位进行异或运算 即 0^0=0,1^0=1,0^1=1,1^1=0( 即不相同是 1, 相同是 0) 例如,a=10100011, 则 a = a ^ 10100011 的结果是 00000000 (5) 保留符号位的右移运算符 :>> 将一个操作数的各个二进制位全部向右移若干位, 左边空出的位全部用最高位的符号位来填充 例如,a = 10100011, 则 a = a>>2 的结果是 a 的值为 11101000 向右移一位相当于整除 2, 用右移实现除法运算速度要比通常的除法运算快 设 a 是 32 位的 int 类型变量, 如 a = 0x7fffffff, 则 b = a >> 31 的结果是 b 的值为 0x00000000 但 b = a >> 34 的结果是 b 的值并不是 0x00000000( 与 b = a >> 2 相同 ), 即 Java 对 32 位整型数的右移, 自动先对所要移动的位的个数进行除以 32 取余数的运算, 然后再进行右移 即若 a 是 int 型变量, 则 a >> n 就是 a >> (n%32) 同理, 若 a 是 64 位的长整数类型,Java 自动先对移动的位的个数进行除以 64 取余数的运算, 然后才进行移位, 即 a >> n 就是 a>> (n%64) 例如,a = 0xffffffff77777777L, 则 b = a>>66 与 b = a >> 2 相同 另外,a>>(-2) 等价于 a>>(-2+32), 即 a>>30 (6) 不保留符号位的右移运算符 :>>> 与 >> 不同的是, 右移后左边空出的位用 0 填充 同样在移位之前, 自动先对所要移动的位的个数 进行除以 32( 或 64) 取余数的运算, 然后再进行右移 即若 a 是 int 型, 则 a >>> n 就是 a >>> (n%32); 若 a 是 long 型, 则 a >>> n 就是 a >>> (n%64) (7) 左移运算符 :<< 将一个操作数的所有二进制位向左移若干位, 右边空出的位填 0 同样, 在移位之前, 自动先对 所要移动的位的个数进行除以 32( 或 64) 取余数的运算, 然后再进行左移 即若 a 是 int 型, 则 a< < n 就是 a << (n%32); 若 a 是 long 型, 则 a << n 就是 a << (n%64) 在不产生溢出的情况下, 左移一位相当于乘以 2, 用左移实现乘法运算的速度比通常的乘法运算 速度要快 5. 赋值运算符 (1) 赋值运算符 := 在 Java 中, 赋值运算符 = 是一个双目运算符, 结合方向从右向左, 用于将赋值符右边操作数 的值赋给左边的变量, 且这个值是整个赋值运算表达式的值 若赋值运算符两边的类型不一致, 且右 边操作数类型不能自动转换到左边操作数类型时, 则需要进行强制类型转换 例如下面的语句 : float f = 2.6f; int i = f; // 出错, 因为 float 不能自动转换成 int 故应改为 : int i = (int) f; // 强制类型转换, 此时 i 的值是 2 (2) 复合赋值运算符 在 Java 中规定了 11 种复合赋值运算符, 如表 2.4 所示 表 2.4 复合赋值运算符 运算符用法举例等效表达式 += op1 += op2 op1 = (T)(op1 + op2),t 是 op1 类型 -= op1 -= op2 op1 = (T)(op1- op2) *= op1 *= op2 op1 = (T)(op1 * op2)

24 Java 实用教程 ( 第 3 版 ) 续表 运算符 用法举例 等效表达式 /= op1 /= op2 op1 = (T)(op1 / op2) %= op1 %= op2 op1 = (T)(op1 % op2) &= op1 &= op2 op1 = (T)(op1 & op2) = op1 = op2 op1 = (T)(op1 op2) ^= op1^= op2 op1 = (T)(op1 ^ op2) >>= op1 >>= op2 op1 = (T)(op1 >> op2) <<= op1 <<= op2 op1 = (T)(op1 << op2) >>>= op1 >>>= op2 op1 = (T)(op1 >>> op2) 各种赋值运算符的优先级均相同且是右结合的 赋值运算符的优先级最低, 如前表 2.3 所示 例如,int x = 1; x += 2.0f, 等价于 x = (int)(x+2.0f) 6. 条件运算符条件运算符?: 是三目运算符, 其格式是 : e1?e2:e3 其中 e1 是一个布尔表达式, 若 e1 的值是 true, 则计算表达式 e2 的值, 且该值即为整个条件运算表达式的值 ; 否则计算表达式 e3 的值, 且该值即为整个条件运算表达式的值 e2 与 e3 需要返回相同或兼容的数据类型, 且该类型不能是 void, 例如,int a=4,b=8; minvalue= a>b? b:a; 2.2.2 表达式表达式是符合一定语法规则的运算符和操作数的序列 一个常量 变量也可认为是一个表达式, 该常量或变量的值即为整个表达式的值 一个合法的 Java 表达式经计算后, 应该有一个确定的值和类型 唯一的例外是方法调用时, 方法的返回值类型可被定义为 void 通常, 不同运算符构成不同的表达式 例如, 关系运算符 > >= 等构成关系表达式, 关系表达式的值只能取 true 或 false, 类型为 boolean 型 2. 3 流程控制 Java 使用了 C 语言的所有流程控制语句, 如分支语句 循环语句 流程跳转语句等, 它们用于控 制程序的运行流程 2.3.1 分支语句 分支语句使部分程序代码在满足特定条件时才会被执行 Java 语言支持两种分支语句 : if else 语句和 switch 语句 1.if else 语句 if 语句又称为条件语句, 其语法格式为 : if (< 布尔表达式 >) < 语句 1>; [else < 语句 2>; ] 其中 :< 语句 1> 及 < 语句 2> 可以是任何语句 ( 包括复合语句 ) else 部分可以有, 也可以没有 < 语句 1> 及 < 语句 2> 位置可以是多个语句, 此时需要用 { 括起 if 语句的语义是 : 首先计算 < 布尔表达式 > 的值, 若值是 true, 则执行 < 语句 1>, 当 < 语句 1> 执行

第 2 章 Java 语法基础 25 完成, 整个 if 语句也就结束了 ; 当 < 布尔表达式 > 的值是 false 时, 执行 else 部分的 < 语句 2>, 当 < 语句 2> 执行完成, 整个 if 语句执行结束 由于 if 语句中的 < 语句 1> 或 < 语句 2> 可以是任何语句, 故当它们 又是另一个 if 语句时, 就产生了 if 语句的嵌套, 例如下面的代码片段 : if (a>1) if (b>10) System.out.println(a+b); else // 此处的 else 与哪一个 if 相配? System.out.println(a-b); 这个嵌套的 if 语句产生了二义性,else 究竟与哪一个 if 相配呢?Java 语言规定 :else 与最近的没 有配上 else 的 if 相配, 故上述 else 与第二个 if 相配 若要使它与第一个 if 相配, 必须修改代码如下 : if (a>1) { // 加上一对 {, 形成一条复合语句 if (b>10) System.out.println(a+b); else System.out.println(a-b); 例 2.4 设计一个 Java 程序, 判断某一年份是否闰年 // 此处的 else 与第一个 if 相配 LeapYear.java public class LeapYear { public static void main(string[] args){ // args[0] 表示命令行的第一个参数并把它由字符串转换为整型 int year = Integer.parseInt(args[0]); int leap; if(year % 4 == 0){ if (year %100 ==0){ if (year %400==0) leap = 1; else leap = 0; else leap =1; else leap = 0; if (leap==1) System.out.println(year +" 年是闰年 "); else System.out.println(year +" 年不是闰年 "); // 1 表示是闰年,0 表示不是闰年 // 判断能否被 4 整除 // 是闰年 右击 LeapYear.java, 选择 Run As Run Configurations 命令, 弹出窗口如图 2.1 所示, 在 Main 标签页的 Project 栏中选择 MyProject_02, 单击 Main class 栏右侧的 Search 按 钮, 弹出对话框中选 LeapYear 切换到 Arguments 标签页, 在 Program argumentds 栏中输入 2016, 然后单击 Run 按钮, 运行程序 程序运行结果 : 2016 年是闰年

26 Java 实用教程 ( 第 3 版 ) 图 2.1 配置程序运行时的输入参数 按照上面同样的方式, 在 Program argumentds 栏输入 2015, 单击 Run 按钮运行程序, 结果为 : 2015 年不是闰年 2.switch 语句 当程序有多个分支 ( 通常超过两个 ) 时, 使用 switch 语句比使用多个嵌套的 if 语句更简明些 switch 语句的语法格式如下 : switch(< 表达式 >) { case < 常量表达式 1>: [< 语句 1>] case < 常量表达式 2>: [< 语句 2>] case < 常量表达式 n>: [< 语句 n>] [default:< 语句 n+1>] 其中 :< 表达式 > 最终值的类型必须是 int 型或者是能自动转换成 int 型的类型, 如 byte short char int, 否则必须进行强制类型转换, 但 Java7 开始增强了 switch 语句功能, 也允许 < 表达式 > 值是 java.lang.string 的字符串类型 < 语句 1>~< 语句 n+1> 可以是任何语句, 也可缺省不写 < 常量表达式 1>~< 常量表达式 n> 在编译时就可计算出它们的值, 并将值作为相应语句的一个标号 由于常量值兼 作标号, 故显然要求不能有两个或以上的值相同 switch 语句的语义是 : 首先计算 < 表达式 > 的值, 然后判断该值与 < 常量表达式 1> 的值是否相等, 若相等, 则从 < 语句 1> 开始, 一直执行到 < 语句 n+1>, 即它是一直执行到底的 ; 否则, 继续判断 < 表达 式 > 的值与 < 常量表达式 2> 的值是否相等, 若相等, 则从 < 语句 2> 开始, 一直执行到底 ; 否则, 继续判 断 < 表达式 > 的值与 < 常量表达式 3> 的值是否相等 若没有一个常量表达式的值与 < 表达式 > 的值相 等, 则从 default 这个标号所代表的语句开始, 一直执行到底

第 2 章 Java 语法基础 27 例 2.5 用 switch 语句判断当前的季节 TestSwitch.java public class TestSwitch { public static void main(string[] args) { // 声明变量 x String x = args[0]; // 直接用字符串型的 args[0] 参数作 switch 的控制表达式, 无须转换类型 switch (x) { case " 春天 ": System.out.println(" 春天般的温暖 ");break; case " 夏天 ": System.out.println(" 夏天一样火热 ");break; case " 秋天 ": System.out.println(" 秋风扫落叶一般 ");break; default: System.out.println(" 严冬一样残酷无情!"); 用之前介绍的操作方法 ( 见前图 2.1) 打开 Run Configurations 窗口, 配置程序运行时的输入参 数, 在 Arguments 标签页的 Program arguments 栏输入 春天, 然后单击 Run 按钮运行程序, 结果为 : 春天般的温暖 2.3.2 循环语句 分内容 : 循环语句的作用是反复执行一段代码, 直到不满足循环条件为止 循环语句一般应包括如下 4 部 (1) 初始化部分 : 用来设置循环的一些初始条件, 比如设置循环控制变量的初始值 (2) 循环条件 : 这是一个布尔表达式, 每一次循环都要对该表达式求值, 以判断是否继续循环 (3) 循环体 : 这是循环操作的主体内容, 可以是一条语句, 也可以是多条 (4) 迭代部分 : 通常属于循环体的一部分, 用来改变循环控制变量的值, 从而改变循环条件表达 式的布尔值 Java 语言包含下列 3 种循环语句 1.while 语句 while 语句的语法格式是 : while(< 布尔表达式 >) { < 语句 1> < 语句 2> < 语句 n> 其中 :< 布尔表达式 > 是循环继续下去的条件, 循环体中的 < 语句 1>~< 语句 n> 可以是任意合法的 Java 语句 若循环体中只有一条语句, 则循环体的一对花特号 { 可省略不写

28 Java 实用教程 ( 第 3 版 ) while 语句的语义是 : (1) 第 1 步 : 计算 < 布尔表达式 > 的值, 若值是 false, 则整个 while 语句执行结束, 程序将继续执行 紧跟在该 while 循环体之后的语句, 而循环体内的语句一次都没有得到执行 若值是 true, 则转第 2 步 (2) 第 2 步 : 依次执行循环体中的 < 语句 1> < 语句 n>, 再转第 1 步 注意 : 循环体或布尔表达式中至少应该有这样的操作, 即它的执行会改变或影响 while(< 布尔表达式 >) 中 < 布尔表达式 > 的值, 否则 while 语句会永远执行下去无法终止, 成为一个死循环 例如 : int a = 1, b = 2; while(a < b) { b++; a += 2; 2.do while 语句 do while 语句的语法格式是 : do { < 语句 1> < 语句 2> < 语句 n> while(< 布尔表达式 >); 其中 :< 布尔表达式 > 是循环继续下去的条件, 循环体中的 < 语句 1> < 语句 n> 可以是任何合法的 Java 语句 注意 : 即使循环体中只有一条语句, 循环体的一对花括号 { 也不能省略 do while 语句的语义是 : (1) 第 1 步 : 依次执行循环体中的 < 语句 1> < 语句 n> (2) 第 2 步 : 计算 < 布尔表达式 > 的值, 若值是 false, 则整个 do while 语句执行结束, 程序继续 执行紧跟在该 do while 语句之后的语句 若值是 true, 转第 1 步 从 do while 语句的语义可知, 循环体中的语句至少执行一次, 即循环体最少执行的次数是 1 同 while 语句一样, 循环体或布尔表达式中至少应该有这样的操作, 它的执行会改变或影响 while(< 布 尔表达式 >) 中 < 布尔表达式 > 的值, 否则,do while 语句也会永远执行下去成为死循环 例 2.6 设计一个 Java 程序, 打印出 1*2*3* *n 之积, 变量 n 的初始值在程序中指定 MultiplyCalculate.java public class MultiplyCalculate { public static void main(string[]args){ long s =1; int k = Integer.parseInt(args[0]); for (int i = 1;i <k;i++){ s = s * i ; System.out.println("1 * 2 * 3"+" * "+k+" = "+ s); // 把字符串转换为整型 // 打印相乘的结果

第 2 章 Java 语法基础 29 用之前介绍的操作方法 ( 见前图 2.1) 打开 Run Configurations 窗口, 配置程序运行时的输入参 数, 在 Arguments 标签页的 Program arguments 栏输入 10, 然后单击 Run 按钮运行程序, 结果为 : 1 * 2 * 3...* 10 = 362880 3.for 语句 for 语句与 while 语句一样, 也是先判断循环条件, 再执行循环体 它的语法格式是 : for (e1; e2; e3) { < 语句 1> < 语句 2> < 语句 n> 其中 :e1 是用逗号分隔的 Java 中任意表达式的列表, 可默认不写, 但其后的分号不能省略 ;e2 是布 尔表达式, 表示循环继续执行的条件, 若该部分默认, 则表示条件永远为真, 成为死循环,e2 后的分 号同样不能省略 ;e3 也是用逗号分隔的 Java 中任意表达式的列表, 同样可以缺省不写 循环体中的 < 语句 1> < 语句 n> 可以是任何合法的 Java 语句 若循环体只有一条语句, 则该循环体的一对花括 号 { 可省略 for 语句的语义是 : (1) 第 1 步 : 首先从左到右依次执行 e1 中用逗号分隔的各个表达式, 这些表达式仅在此执行一次, 以后不再执行, 通常用于变量初始化赋值 (2) 第 2 步 : 计算布尔表达式 e2 的值, 若值为 false, 则整个 for 循环语句执行结束, 程序继续执 行紧跟在该 for 语句之后的语句 ; 若值为 true, 则依次执行循环体中的 < 语句 1> < 语句 n> (3) 第 3 步 : 从左到右依次执行 e3 中用逗号分隔的各个表达式, 再转第 2 步 例 2.7 设计一个 Java 程序, 输出所有的水仙花数 所谓水仙花数, 是指一个 3 位数, 其各位数 字的立方和等于该数自身, 例如,153 = 1 3 +5 3 +3 3 TestNum.java public class TestNum { public static void main(string[] args){ int i = 0; int j = 0; int k = 0; int n = 0; int p = 0; for( int m = 100; m <1000; m++){ i = m /100; n = m %100; j = n /10; k = n %10; p = i*i*i+j*j*j+k*k*k; if (p==m){ System.out.println(m); // 百位数 // 十位数 // 个位数 // 得到百位数 // 得到十位数 // 得到个位数 // 打印水仙花数

30 Java 实用教程 ( 第 3 版 ) 程序运行结果 : 153 370 371 407 2.3.3 流程跳转语句 break continue 和 return 语句用来控制流程的跳转 (1)break 语句 : 从 switch 语句 循环语句或标号标识的代码块中退出 例如, 以下 while 循环 语句用于计算从 1 加到 100 的值, 至 101 时自动退出 : int a = 1,result = 0; while (true) { result += a++; if (a == 101) break; System.out.println(result); (2)continue 语句 : 跳过本次循环, 立即开始新的一轮循环 例 2.8 打印 100~200 之间能被 3 整除的数, 每 10 个数一行 TestContinue.java public class TestContinue { public static void main(string[] args) { int n = 0; int i = 0; for (n = 100; n <= 200; n++) { if (n % 3!= 0) continue; // 不能被 3 整除, 结束本次循环 程序运行结果 : i++; System.out.print(n + " "); if (i % 10 == 0) { System.out.println(); // 每 10 个数一行 102 105 108 111 114 117 120 123 126 129 132 135 138 141 144 147 150 153 156 159 162 165 168 171 174 177 180 183 186 189 192 195 198 (3)return 语句 : 退出本方法, 跳到上层调用方法 如果本方法的返回类型不是 void, 则需要提 供相应类型的返回值