下 面 我 们 分 别 来 介 绍 Java中 的 流 控 制 语 句 ,包 括

1.分 支 语 句 :if-else, break, switch, return.

2.循 环 语 句 :while, do-while, for, continue.

3.例 外 处 理 语 句 :try-catch-finally, throw

最 后 我 们 简 单 介 绍 一 下 注 释 语 句 。

§ 4.1分 支 语 句

分 支 语 句 提 供 了 一 种 控 制 机 制 ,使 得 程 序 的 执 行 可 以 跳 过 某 些 语 句 不 执 行 ,而 转 去 执

行 特 定 的 语 句 。

4.1.1条 件 语 句 if-else.

if-else语 句 根 据 判 定 条 件 的 真 假 来 执 行 两 种 操 作 中 的 一 种 , 它 的 格 式 为 :

if(boolean-expression)

statement1;

[else

statement2;]

1.布 尔 表 达 式 boolean-expression是 任 意 一 个 返 回 布 尔 型 数 据 的 表 达 式 (这 比 C、 C++的 限 制

要 严 格 )。

2.每 个 单 一 的 语 句 后 都 必 须 有 分 号 。

3.语 句 statement1,statement2可 以 为 复 合 语 句 ,这 时 要 用 大 括 号 {} 括 起 。 建 议 对 单 一 的 语 句

也 用 大 括 号 括 起 ,这 样 程 序 的 可 读 性 强 ,而 且 有 利 于 程 序 的 扩 充 (可 以 在 其 中 填 加 新 的 语 句

)。 {}外 面 不 加 分 号 。

4.else子 句 是 任 选 的 。

5.若 布 尔 表 达 式 的 值 为 true,则 程 序 执 行 statement1,否 则 执 行 st atement2。

6.if-else语 句 的 一 种 特 殊 形 式 为 :

if(expression1){

statement1

}else if (expression2){

statement2

}……

}else if (expressionM){

statementM

}else {

statementN

}

@@@[

else子句不能单独作为语句使用,它必须和if配对使用。else总是与离它最近的if配对

。可以通过使用大括号{}来改变配对关系。

7.举例:

例4.1 比较两个数的大小,并按从小到大的次序输出。

@@@[

public class CompareTwo{

public static void main( String args[] ){

double d1=23.4;

double d2=35.1;

if(d2＞=d1)

System.out.println(d2+” ＞= “+d1);

else

System.out.println(d1+” ＞= “+d2);

}

}

运行结果为:

C:＞java CompareTwo

35.1 ＞= 23.4

例 4.2 判 断 某 一 年 是 否 为 闰 年 。

闰 年 的 条 件 是 符 合 下 面 二 者 之 一 :① 能 被 4整 除 ,但 不 能 被 10 0整 除 ;② 能 被 4整 除 ,又 能 被

100整 除 。

public class LeapYear{

public static void main( String args[] ){

int year=1989; //method 1

if( (year%4==0 && year%100!=0) || (year%400==0) )

System.out.println(year+” is a leap year.”);

else

System.out.println(year+” is not a leap year.”);

year=2000; //method 2

boolean leap;

if( year%4!=0 )

leap=false;

else if( year%100!=0 )

leap=true;

else if( year%400!=0 )

leap=false;

else

leap=true;

if( leap==true )

System.out.println(year+” is a leap year.”);

else

System.out.println(year+” is not a leap year.”);

year=2050; //method3

if( year%4==0){

if( year%100==0 ){

if( year%400==0)

leap=true;

else

leap=false;

}else

leap=false;

}else

leap=false;

if( leap==true )

System.out.println(year+” is a leap year.”);

else

System.out.println(year+” is not a leap year.”);

}

}

运行结果为

C:＞java LeapYear

1989 is not a leap year.

2000 is a leap year.

2050 is not a leap year.

该 例 中 ,方 法 1用 一 个 逻 辑 表 达 式 包 含 了 所 有 的 闰 年 条 件 ,方 法 2使 用 了 if-else语 句 的 特 殊

形 式 ,方 法 3则 通 过 使 用 大 括 号 {}对 if-else进 行 匹 配 来 实 现 闰 年 的 判 断 。 大 家 可 以 根 据 程 序 来

对 比 这 三 种 方 法 ,体 会 其 中 的 联 系 和 区 别 ,在 不 同 的 场 合 选 用 适 合 的 方 法 。

4.1.2多 分 支 语 句 switch

switch 语 句 根 据 表 达 式 的 值 来 执 行 多 个 操 作 中 的 一 个 ,它 的 一 般 格 式 如 下 :

switch (expression){

case value1 : statement1;

break;

case value2 : statement2;

break;

…………

case valueN : statemendN;

break;

[default : defaultStatement; ]

}

1.表 达 式 expression可 以 返 回 任 一 简 单 类 型 的 值 (如 整 型 、 实 型 、 字 符 型 ),多 分 支 语 句 把

表 达 式 返 回 的 值 与 每 个 case子 句 中 的 值 相 比 。 如 果 匹 配 成 功 ,则 执 行 该 case子 句 后 的 语 句 序

列 。

2.case子 句 中 的 值 valueI必 须 是 常 量 ,而 且 所 有 case子 句 中 的 值 应 是 不 同 的 。

3.default子 句 是 任 选 的 。 当 表 达 式 的 值 与 任 一 case子 句 中 的 值 都 不 匹 配 时 ,程 序 执 行

default后 面 的 语 句 。 如 果 表 达 式 的 值 与 任 一 case子 句 中 的 值 都 不 匹 配 且 没 有 default子 句 ,则 程

序 不 作 任 何 操 作 ,而 是 直 接 跳 出 switch语 句 。

4.break语 句 用 来 在 执 行 完 一 个 case分 支 后 ,使 程 序 跳 出 switch语 句 ,即 终 止 switch语 句 的 执 行

。 因 为 case子 句 只 是 起 到 一 个 标 号 的 作 用 ,用 来 查 找 匹 配 的 入 口 并 从 此 处 开 始 执 行 ,对 后 面

的 case子 句 不 再 进 行 匹 配 ,而 是 直 接 执 行 其 后 的 语 句 序 列 , 因 此 应 该 在 每 个 case分 支 后 ,要 用

break来 终 止 后 面 的 case分 支 语 句 的 执 行 。

在 一 些 特 殊 情 况 下 ,多 个 不 同 的 case值 要 执 行 一 组 相 同 的 操 作 ,这 时 可 以 不 用 break。

5.case分 支 中 包 括 多 个 执 行 语 句 时 ,可 以 不 用 大 括 号 {}括 起 。

6.switch语 句 的 功 能 可 以 用 if-else来 实 现 ,但 在 某 些 情 况 下 ,使 用 switch语 句 更 简 炼 ,可 读 性 强

,而 且 程 序 的 执 行 效 率 提 高 。

7.举 例 :

例 4.3.根 据 考 试 成 绩 的 等 级 打 印 出 百 分 制 分 数 段 。

public class GradeLevel{

public static void main( String args[] ){

System.out.println(“n** first situation **”);

char grade=’C'; //normal use

switch( grade ){

case ‘A’ : System.out.println(grade+” is 85～100″);

break;

case ‘B’ : System.out.println(grade+” is 70～84″);

break;

case ‘C’ : System.out.println(grade+” is 60～69″);

break;

case ‘D’ : System.out.println(grade+” is ＜60″);

break;

default : System.out.println(“input error”);

}

System.out.println(“n** second situation **”);

grade=’A'; ∥creat error without break statement

switch( grade ){

case ‘A’ : System.out.println(grade+” is 85～100″);

case ‘B’ : System.out.println(grade+” is 70～84″);

case ‘C’ : System.out.println(grade+” is 60～69″);

case ‘D’ : System.out.println(grade+” is ＜60″);

default : System.out.println(“input error”);

}

System.out.println(“n** third situation **”);

grade=’B'; ∥several case with same operation

switch( grade ){

case ‘A’ :

case ‘B’ :

case ‘C’ : System.out.println(grade+” is ＞=60″);

break;

case ‘D’ : System.out.println(grade+” is ＜60″);

break;

default : System.out.println(“input error”);

}

}

}

运行结果为

C:＞java GradeLevel

**** first situation ****

C is 60～69

**** second situation ****

A is 85～100

A is 70～84

A is 60～69

A is ＜60

input error

**** third situation ****

B is ＞=60

从 该 例 中 我 们 可 以 看 到 break语 句 的 作 用 。

4.1.3 break语 句

1.在 switch语 中 ,break语 句 用 来 终 止 switch语 句 的 执 行 。 使 程 序 从 switch语 句 后 的 第 一 个 语 句

开 始 执 行 。

2.在 Java中 ,可 以 为 每 个 代 码 块 加 一 个 括 号 ,一 个 代 码 块 通 常 是 用 大 括 号 {}括 起 来 的 一 段

代 码 。 加 标 号 的 格 式 如 下 :

BlockLabel: { codeBlock }

break语 句 的 第 二 种 使 用 情 况 就 是 跳 出 它 所 指 定 的 块 ,并 从 紧 跟 该 块 的 第 一 条 语 句 处 执

行 。 其 格 式 为 :

break BlockLabel;

例如:

a:{…… //标记代码块a

b: {…… //标记代码块b

c: {…… //标记代码块c

break b;

…… //will not be executed

}

…… //will not be executed

}

…… /execute from here

}

3.与 C、 C++不 同 ,Java中 没 有 goto语 句 来 实 现 任 意 的 跳 转 ,因 为 g oto语 句 破 坏 程 序 的 可 读 性

,而 且 影 响 编 译 的 优 化 。 但 是 从 上 例 可 以 看 出 ,Java用 break来 实 现 goto语 句 所 特 有 的 一 些 优 点

。 如 果 break后 所 指 定 的 标 号 不 是 一 个 代 码 块 的 标 号 ,而 是 一 个 语 句 ,则 这 时 break完 全 实 现

goto的 功 能 。 不 过 应 该 避 免 这 种 方 式 的 使 用 。 　  (未 完 待 续 )

4.1.4返 回 语 句 return

return语 句 从 当 前 方 法 中 退 出 ,返 回 到 调 用 该 方 法 的 语 句 处 , 并 从 紧 跟 该 语 句 的 下 一 条 语

句 继 续 程 序 的 执 行 。 (有 关 方 法 的 内 容 ,我 们 将 在 第 六 章 详 细 讲 述 。 前 面 例 子 中 的 main( )就

是 一 个 方 法 )。 返 回 语 句 有 两 种 格 式 :

1.return expression

返 回 一 个 值 给 调 用 该 方 法 的 语 句 ,返 回 值 的 数 据 类 型 必 须 和 方 法 声 明 中 的 返 回 值 类 型

一 致 。 可 以 使 用 强 制 类 型 转 换 来 使 类 型 一 致 。

2.return

当 方 法 说 明 中 用 void声 明 返 回 类 型 为 空 时 ,应 使 用 这 种 格 式 ,它 不 返 回 任 何 值 。

return 语 句 通 常 用 在 一 个 方 法 体 的 最 后 ,以 退 出 该 方 法 并 返 回 一 个 值 。 Java中 ,单 独 的

return语 句 用 在 一 个 方 法 体 的 中 间 时 ,会 产 生 编 译 错 误 ,因 为 这 时 会 有 一 些 语 句 执 行 不 到 。 但

可 以 通 过 把 return语 句 嵌 入 某 些 语 句 (如 if-else)来 使 程 序 在 未 执 行 完 方 法 中 的 所 有 语 句 时 退 出

,例 如 :

int method (int num) {

∥ return num; ∥will cause compile time error

if (num＞0)

return num;

……　∥ may or may not be executed

∥depending on the value of num

§ 4.2循 环 语 句

循 环 语 句 的 作 用 是 反 复 执 行 一 段 代 码 ,直 到 满 足 终 止 循 环 的 条 件 为 止 ,一 个 循 环 一 般

应 包 括 四 部 分 内 容 :

1.初 始 化 部 分 (initialization):用 来 设 置 循 环 的 一 些 初 始 条 件 , 如 计 数 器 清 零 等 。

2.循 环 体 部 分 (body):这 是 反 复 循 环 的 一 段 代 码 ,可 以 是 单 一 的 一 条 语 句 ,也 可 以 是 复 合 语

句 。

3.迭 代 部 分 (iteration):这 是 在 当 前 循 环 结 束 ,下 一 次 循 环 开 始 前 执 行 的 语 句 ,常 常 用 来 使 计

数 器 加 1或 减 1。

4.终 止 部 分 (termination):通 常 是 一 个 布 尔 表 达 式 ,每 一 次 循 环 都 要 对 该 表 达 式 求 值 ,以 验 证

是 否 满 足 循 环 终 止 条 件 。

Java中 提 供 的 循 环 语 句 有 :while语 句 ,do-while语 句 和 for语 句 ,下 面 分 别 介 绍 。

4.2.1while语 句

while语 句 实 现 “当 型 “循 环 ,它 的 一 般 格 式 为 ;

[initialization]

while (termination){

body;

[iteration;]

}

1.当 布 尔 表 达 式 (termination)的 值 为 true时 ,循 环 执 行 大 括 号 中 的 语 句 。 并 且 初 始 化 部 分 和

迭 代 部 分 是 任 选 的 。

2.while语 句 首 先 计 算 终 止 条 件 ,当 条 件 满 足 时 ,才 去 执 行 循 环 体 中 的 语 句 。 这 是 “当 型 “循

环 的 特 点 。

4.2.2 do-while语 句

do-while 语句实现”直到型”循环,它的一般格式为:

[initialization]

do {

body;

[iteration;]

} while (termination);

1.do-while语 句 首 先 执 行 循 环 体 ,然 后 计 算 终 止 条 件 ,若 结 果 为 true,则 循 环 执 行 大 括 号 中 的

语 句 ,直 到 布 尔 表 达 式 的 结 果 为 false。

2.与 while语 句 不 同 的 是 ,do-while语 句 的 循 环 体 至 少 执 行 一 次 , 这 是 “直 到 型 “循 环 的 特 点 。

4.2.3 for语 句

for语 句 也 用 来 实 现 “当 型 “循 环 ,它 的 一 般 格 式 为 :

for (initialization; termination; iteration){

body;

}

1.for语 句 执 行 时 ,首 先 执 行 初 始 化 操 作 ,然 后 判 断 终 止 条 件 是 否 满 足 ,如 果 满 足 ,则 执 行 循

环 体 中 的 语 句 ,最 后 执 行 迭 代 部 分 。 完 成 一 次 循 环 后 ,重 新 判 断 终 止 条 件 。

2.可 以 在 for语 句 的 初 始 化 部 分 声 明 一 个 变 量 ,它 的 作 用 域 为 整 个 for 语 句 。

3.for语 句 通 常 用 来 执 行 循 环 次 数 确 定 的 情 况 (如 对 数 组 元 素 进 行 操 作 ),也 可 以 根 据 循 环

结 束 条 件 执 行 循 环 次 数 不 确 定 的 情 况 。

4.在 初 始 化 部 分 和 迭 代 部 分 可 以 使 用 逗 号 语 句 ,来 进 行 多 个 操 作 。 逗 号 语 句 是 用 逗 号

分 隔 的 语 句 序 列 。 例 如 :

for( i=0, j=10; i＜j; i++, j–){

……

}

5.初 始 化 、 终 止 以 及 迭 代 部 分 都 可 以 为 空 语 句 (但 分 号 不 能 省 ),三 者 均 为 空 的 时 候 ,相

当 于 一 个 无 限 循 环 。

4.2.4 continue语 句

1.continue语 句 用 来 结 束 本 次 循 环 ,跳 过 循 环 体 中 下 面 尚 未 执 行 的 语 句 ,接 着 进 行 终 止 条

件 的 判 断 ,以 决 定 是 否 继 续 循 环 。 对 于 for语 句 ,在 进 行 终 止 条 件 的 判 断 前 ,还 要 先 执 行 迭 代

语 句 。 它 的 格 式 为 :

continue;

2.也 可 以 用 continue跳 转 到 括 号 指 明 的 外 层 循 环 中 ,这 时 的 格 式 为

continue outerLable;

例 如 :

outer: for( int i=0; i＜10; i++ ){ ∥外层循环

for( int j=0; j＜20; j++ ){ ∥内层循环

if( j＞i ){

……

continue outer;

}

……

}

……

}

该 例 中 ,当 满 足 j＞i的 条 件 时 ,程 序 执 行 完 相 应 的 语 句 后 跳 转 到 外 层 循 环 ,执 行 外 层 循 环

的 迭 代 语 句 i++;然 后 开 始 下 一 次 循 环 。

4.2.5举 例

例 4.4 下 例 分 别 用 while、 do-while和 for语 句 实 现 累 计 求 和 。

public class Sum{

public static void main( String args[] ){

System.out.println(“n** while statement **”);

int n=10,sum=0; ∥initialization

while( n＞0 ){ ∥termination

sum+=n; ∥body

n–; ∥iteration

}

System.out.println(“sum is “+sum);

System.out.println(“n** do_while statement **”);

n=0; ∥initialization

sum=0;

do{

sum+=n; ∥body

n++; ∥iteration

}while( n＜=10 ); ∥termination

System.out.println(“sum is “+sum);

System.out.println(“n** for statement **”);

sum=0;

for( int i=1; i＜=10; i++){

∥initialization,termination,iteration

sum+=i;

}

System.out.println(“sum is “+sum);

}

}

运行结果为:

C:＞java Sum

** while statement **

sum is 55

** do_while statement **

sum is 55

** for statement **

sum is 55

可以从中来比较这三种循环语句,从而在不同的场合选择合适的语句。

例4.5 求100～200间的所有素数

public class PrimeNumber{

public static void main( String args[] ){

System.out.println(” ** prime numbers between 100 and 200 **”);

int n=0;

outer:for(int i=101;i＜200;i+=2){ ∥outer loop

int k=15; ∥select for convinence for(int j=2;j＜=k;j++){ ∥inner loop

if( i%j==0 )

continue outer;

}

System.out.print(” “+i);

n++; ∥output a new line

if( n＜10 ) ∥after 10 numbers

continue;

System.out.println();

n=0;

}

System.out.println();

}

}

运行结果为:

C:＞java PrimeNumber

** prime numbers between 100 and 200 **

101 103 107 109 113 127 131 137 139 149

151 157 163 167 173 179 181 191 193 197

199

该 例 通 过 一 个 嵌 套 的 for语 句 来 实 现 。 !U4§ 4.3例 外 处 理 语 句

例 外 处 理 语 句 包 括 try、 catch、 finally以 及 throw语 句 。 与 C、 C+ +相 比 ,例 外 处 理 语 句 是

Java所 特 有 的 。 我 们 将 在 第 八 章 作 专 门 的 介 绍 。 !U4§ 4.4 注 释 语 句

Java中 可 以 采 用 三 种 注 释 方 式 :

1.算 术 运 算 符 (+,-,*,/,%,++,–)

2.关 系 运 算 符 (＞,＜,＞=,＜=,==,!=)

3.布 尔 逻 辑 运 算 符 (!,&&,||)

4.位 运 算 符 (＞＞,＜＜,＞＞＞,&,|,^,～ )

5.赋 值 运 算 符 (=,及 其 扩 展 赋 值 运 算 符 如 +=)

6.条 件 运 算 符 ( ?:)

7.其 它 (包 括 分 量 运 算 符 · ,下 标 运 算 符 [],实 例 运 算 符 instanc eof,内 存 分 配 运 算 符 new,强 制 类

型 转 换 运 算 符 (类 型 ),方 法 调 用 运 算 符 () 等 )

本 章 中 我 们 主 要 讲 述 前 6类 运 算 符 。

§ 3.1算 术 运 算 符

算 术 运 算 符 作 用 于 整 型 或 浮 点 型 数 据 ,完 成 算 术 运 算 。

一 、 二 元 算 术 运 算 符 ,如 下 表 所 示

运算符 用法 描述

+ op1+op2 加

- op1-op2 减

* op1*op2 乘

/ op1/op2 除

% op1%op2 取模(求余)

Java对 加 运 算 符 进 行 了 扩 展 ,使 它 能 够 进 行 字 符 串 的 连 接 ,如 “abc”+”de”,得 到 串 “abcde”。 我

们 将 在 第 七 章 中 讲 解 。

与 C、 C++不 同 ,对 取 模 运 算 符 %来 说 ,其 操 作 数 可 以 为 浮 点 数 , 如 37.2%10=7.2。

二 、 一 元 算 术 运 算 符 ,如 下 表 所 示 :

运算符 用法 描述

+ +op 正值

- -op 负值

++ ++op,op++ 加1

– –op,op– 减1

i++与 ++i的 区 别

i++在 使 用 i之 后 ,使 i的 值 加 1,因 此 执 行 完 i++后 ,整 个 表 达 式 的 值 为 i,而 i的 值 变 为 i+1。

++i在 使 用 i之 前 ,使 i的 值 加 1,因 此 执 行 完 ++i后 ,整 个 表 达 式 和 i的 值 均 为 i+1。

对 i–与 –i同 样 。

例 3.1.下 面 的 例 子 说 明 了 算 术 运 算 符 的 使 用

public class ArithmaticOp{

public static void main( String args[] ){

int a=5+4; //a=9

int b=a*2; //b=18

int c=b/4; //c=4

int d=b-c; //d=14

int e=-d; //e=-14

int f=e%4; //f=-2

double g=18.4;

double h=g%4; //h=2.4

int i=3;

int j=i++; //i=4,j=3

int k=++i; //i=5,k=5

System.out.println(“a = “+a);

System.out.println(“b = “+b);

System.out.println(“c = “+c);

System.out.println(“d = “+d);

System.out.println(“e = “+e);

System.out.println(“f = “+f);

System.out.println(“g = “+g);

System.out.println(“h = “+h);

System.out.println(“i = “+i);

System.out.println(“j = “+j);

System.out.println(“k = “+k);

}

}

其结果为:

C:＞java ArithmaticOp

a = 9

b = 18

c = 4

d = 14

e = -14

f = -2

g = 18.4

h = 2.4

i = 5

j = 3

k = 5

§ 3.2关 系 运 算 符

关 系 运 算 符 用 来 比 较 两 个 值 ,返 回 布 尔 类 型 的 值 true或 false。 关 系 运 算 符 都 是 二 元 运 算

符 ,如 下 表 所 示 :

运算符 用法 返回true的情况

＞ op1＞op2 op1大于op2

＞+ op1＞=op2 op1大于或等于op2

＜ op1＜op2 op1小于op2

＜= op1＜=op2 op1小于或等于op2

== op1==op2 op1与op2相等

!= op1!=op2 op1与op2不等

Java中 ,任 何 数 据 类 型 的 数 据 (包 括 基 本 类 型 和 组 合 类 型 )都 可 以 通 过 ==或 !=来 比 较 是 否

相 等 (这 与 C、 C++不 同 )。

关 系 运 算 的 结 果 返 回 true或 false,而 不 是 C、 C++中 的 1或 0。

关 系 运 算 符 常 与 布 尔 逻 辑 运 算 符 一 起 使 用 ,作 为 流 控 制 语 句 的 判 断 条 件 。 如

if( a＞b && b==c)

§ 3.3布 尔 逻 辑 运 算 符

布 尔 逻 辑 运 算 符 进 行 布 尔 逻 辑 运 算 ,如 下 表 所 示 :

op1 op2 op1&&op2 op1||op2 !op1

false false false false true

false true false true true

true false false true false

true true true true false

}@@@

·&&、‖　为二元运算符,实现逻辑与、逻辑或。

·! 为一元运算符,实现逻辑非。

·对于布尔逻辑运算,先求出运算符左边的表达式的值,对或运算如果为true,则整个表

达式的结果为true,不必对运算符右边的表达式再进行运算;同样,对与运算,如果左边表达式

的值为false,则不必对右边的表达式求值,整个表达式的结果为false。

下面的例子说明了关系运算符和布尔逻辑运算符的使用。

@@@[

public class RelationAndConditionOp{

public static void main( String args[] ){

int a=25,b=3;

boolean d=a＜b; //d=false

System.out.println(“a＜b = “+d);

int e=3;

if(e!=0 && a/e＞5)

System.out.println(“a/e = “+a/e);

int f=0;

if(f!=0 && a/f＞5)

System.out.println(“a/f = “+a/f);

else

System.out.println(“f = “+f);

}

}

其运行结果为:

C:＞java RelationAndConditionOp

a＜b = false

a/e = 8

f = 0

注 意 :上 例 中 ,第 二 个 if语 句 在 运 行 时 不 会 发 生 除 0溢 出 的 错 误 ,因 为 e!=0为 false,所 以 就 不 需

要 对 a/e进 行 运 算 。

§ 3.4位 运 算 符

位 运 算 符 用 来 对 二 进 制 位 进 行 操 作 ,Java中 提 供 了 如 下 表 所 示 的 位 运 算 符 :

位 运 算 符 中 ,除 　 ～ 　 以 外 ,其 余 均 为 二 元 运 算 符 。

操 作 数 只 能 为 整 型 和 字 符 型 数 据 。

3.4.1补 码

Java使 用 补 码 来 表 示 二 进 制 数 ,在 补 码 表 示 中 ,最 高 位 为 符 号 位 ,正 数 的 符 号 位 为 0,负 数

为 1。 补 码 的 规 定 如 下 :

对 正 数 来 说 ,最 高 位 为 0,其 余 各 位 代 表 数 值 本 身 (以 二 进 制 表 示 ),如 +42的 补 码 为

00101010。

对 负 数 而 言 ,把 该 数 绝 对 值 的 补 码 按 位 取 反 ,然 后 对 整 个 数 加 1,即 得 该 数 的 补 码 。 如

-42的 补 码 为 11010110 (00101010 按 位 取 反 11010101 +1 11010110 )

用 补 码 来 表 示 数 ,0的 补 码 是 唯 一 的 ,都 为 00000000。 (而 在 原 码 ,反 码 表 示 中 ,+0和 -0的 表 示

是 不 唯 一 的 ,可 参 见 相 应 的 书 籍 )。 而 且 可 以 用 111111表 示 -1的 补 码 (这 也 是 补 码 与 原 码 和 反

码 的 区 别 )。

3.4.2按 位 取 反 运 算 符 　 ～

～ 　 是 一 元 运 算 法 ,对 数 据 的 每 个 二 进 制 位 取 反 ,即 把 1变 为 0,把 0变 为 1。

例 如 :

0010101

～

1101010

注 意 ,～ 运 算 符 与 – 运 算 符 不 同 ,～ 21≠ -21。

3.4.3按 位 与 运 算 符 &

参 与 运 算 的 两 个 值 ,如 果 两 个 相 应 位 都 为 1,则 该 位 的 结 果 为 1,否 则 为 0。 即 :