Java运算符、表达式以及流程控制

第二章 Java运算符、表达式以及流程控制


运算符指明对操作数所进行的运算。按操作数的数目来分一元(如+-)，二元运算符(如+、>)和三元运算符(如?:)，Java运算符、表达式以及流程控制它们分别对应于一元运算符来说，可以有前缀表达式(如++i)和后缀表达式(如采用中缀表达式(如a+b)。按照运算符功能来分，基本的运算符分下面几类：

1.算术运算符(+，-，*，/，%，++，--)
2.关系运算符(＞，＜，＞=，＜=，==，!=)
3.布尔逻辑运算符(!，&&，||，—，|)
4.位运算符(＞＞，＜＜，＞＞＞，&，|，^，～)
5.赋值运算符(=，及其复合赋值运算符如+=)
6.条件运算符(?:)

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

§2.1 算术运算符

算术运算符作用于整型或浮点型数据，完成算术运算。
一、二元算术运算符，如下表所示：

运算符 运算 举例说 明
+ 加 a+b 求a与b相加的和
+ 减 a-b 求a与b相减的差
* 乘 a*b 求a与b相乘的积
/ 除 a/b 求a除以b的商
% 取模 a%b 求a除以b所得的余数

运算符 用法 描述
+ op1+op2 加
- op1-op2 减
* op1*op2 乘
/ op1/op2 除
% op1%op2 取模(求余)

Java对"加"运算符进行了扩展，使它能够进行字符串的连接，如"abc"+"de"，得到串"abcde"。我们将在以后讲解。

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

二、一元算术运算符

运算符 说 明
+ 正值
- 负值
++ 自加1
-- 自减1

i++与++i的区别：

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

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

对i--与--i同样。

浮点变量也可以使用++和--操作符，作用与整型变量相同。

例2.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

§2.2 关系运算符

关系运算符用来比较两个值，返回布尔类型的值true或false，关系运算符都是二元运算符，如下表所示：

运算符 含义 举例 说 明
< 小于 a<b a小于b
<= 小于等于 a<=b a小于等于b
> 大于 a>b a大于b
>= 大于等于 a>=b a大于等于b
== 等于 a==b a等于b
!= 不等于 a!=b a不等于b




Java中，任何数据类型的数据(包括基本类型和组合类型)都可以通过==或!=来比较是否相等(这与C、C++不同)。

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

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

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

例2.2 下面的例子说明了关系运算符的使用

public class CompareNumber
{
public static void main(String[] args)
{
int n=3;
int m=4;
System.out.println();
System.out.println("n<m is "+(n<m));
System.out.println("n=m is "+((++n)==m));
System.out.println("n>m is "+((++n)>m));
System.out.println("n is "+n);

}
}

其结果为：

C:\＞java CompareNumber

n<m is true
n=m is true
n>m is true
n is 5

§2.3 布尔逻辑运算符

逻辑运算是针对布尔型数据进行的运算，运算的结果仍然是布尔型量。常用的运算符如下:

运算符 运算 例子 说 明
！ 逻辑非 !x x真时为假，x假时为真
&& 逻辑与 x&&y x,y都真时结果才为真
& 非简洁与 x&y x,y都真时结果才为真
|| 逻辑或 x||y x,y都假时结果才为假
| 非简洁或 x|y x,y都假时结果才为假
^ 取或 x^y x,y同真假时结果为假

真值表：

op1 op2 op1&&op2 op1&op2 op1||op2 op1|op2 !op1
false false false false false false true
false true false false true true true
true false false false true true false
true true true true true true false


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

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

1.对于布尔逻辑运算，先求出运算符左边的表达式的值，然后在运算；

2.对逻辑或||的运算，如果左边表达式的值为true，则整个表达式的结果为true，不必对运算符右边的表达式再进行运算,非简洁或|和逻辑或||的真值表是一样的，不同的是运算符右边的表达式无论什么情况都要运算；

3.对逻辑与&&运算，如果左边表达式的值为false，则不必对右边的表达式求值，整个表达式的结果为false。非简洁与&和逻辑与&&的真值表是一样的，不同的是运算符右边的表达式无论什么情况都要运算；

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

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进行运算。

§2.4 位运算符

位运算是对操作数以二进制为单位进行的操作和运算，位运算的操作数和结果都是整形变量，Java中提供了如下表所的位运算符：位运算符中，除　～　以外，其余均为二元运算符。操作数只能为整型和字符型数据。


运算符 运算 例子 说 明
~ 求补(位反) ~x 将x按比特位取反
<< 向左移位,从右边补0 x>>a x各比特位左移a位
>> 向右移位,从坐侧传递符号位 x<<a x各比特位右移a位
>>> 无符号向右移位,从左边补0 x>>>a x各比特位右移a位，左边的空位填零


位运算符通常与硬件打交道时用到，在Java中一般不太常用。

§2.5 赋值运算符(复合赋值运算符)

赋值语句是程序设计最基本的语句之一，赋值运算的符号是等号，其右部是一个表达式，左部是变量，它把右部的值赋给左部的变量，等号左边的变量称为左值 lvalue，右边称为右值rvalue。在Java中，赋值语句像函数一样有返回值，它的返回值即左值，有些语言没有这一特点。

运算符 例子 解释
+= x+=a x=x+a
-+ x-=a x=x-a
*= x*=a x=x*a
/= x/=a x=x/a
%= x%=a x=x%a
&= x&=a x=x&a
|= x|=a x=x|a
^= x^=a x=x^a
<<= x<<=a x=x<<a
>>= x>>=a x=x>>a
<<<= x<<<=a x=x<<<a

例2.4下面的例子说明了赋值运算的使用。

　

public class LValue{
public static void main(String[] args){
int x=1,y=12;
x+=2;
y-=3;
System.out.println();
System.out.println("x= "+x+" y= "+y);
y/=x;
System.out.println("x= "+x+" y= "+y);
y++;
y%=x;
System.out.println("x= "+x+" y= "+y);
}
}


其运行结果为：

C:\＞java LValue

x= 3 y= 9
x= 3 y= 3
x= 3 y= 1


§2.6 三目运算符
Java中的三墓运算符与C语言中的完全相同，使用形式为：
x?y:z;
这就是说，先计算x的值，若x为真，怎整个表达式的结果为y的值，若x为假，则整个表达式的值为表达式z的值。
例如：
int x=5,y=8,z=2;
int k=x<3?y:z; //因为x<3，所以k=z=2；
int j=x>0?x:-x //y的值始终为x的绝对值。


§2.7 表达式

表达式是由变量、常量、对象、方法调用和操作符组成的式子。符合语法规则的表达式才能被编译系统理解、执行并计算。

说起表达式，也并不是很复杂，就是日常我们见到的数学式子，但有一些区别，Java中的表达式由于操作符的不同，而有很多的种类了。

§2.8 流程控制语句

能够决定其它语句的执行顺序的语句称为流程控制语句。Java语言里有如下语句：

选择判断语句：if-else, switch-case

循环语句： for, while, do-while

其他控制语句：break, continue, label: , return



§2.9 选择判断语句

条件语句if-else

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

if(boolean-expression){
statement1;
}else{
statement2;
}
1.布尔表达式boolean-expression是任意一个返回布尔型数据的达式(这比C、C++的限制要严格)。

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

3.语句statement1，statement2可以为复合语句，这时要用大括号{}括起。建议对单一的语句也用大括号括起，这样程序的可读性强，而且有利于程序的扩充(可以在其中填加新的语句)。{}外面不加分号。

4.else子句是任选的。

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

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

if(expression1){
statement1;
}else if(expression2){
statement2;
}......
}else if(expressionM){
statementM;
}else{
statementN;
}

else子句不能单独作为语句使用，它必须和if配对使用。else总是与离它最近的if配对。可以通过使用大括号{}来改变配对关系。


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



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整除，但不能被100整除;②能被4整除，又能被100整除。



public class LeapYear{
public static void main(String args[]){
int year=1989;//method1
if((year%4==0&&year%100!=0)||(year%400==0))
System.out.println(year+"年是闰年。.");
else
System.out.println(year+"年不是闰年。");
year=2000;//method2
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+"年是闰年。");
else
System.out.println(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+"年是闰年。");
else
System.out.println(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进行匹配来实现闰年的判断。大家可以根据程序来对比这三种方法，体会其中的联系和区别，在不同的场合选用适当的方法。

多分支语句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语句更简炼，可读性强，而且程序的执行效率提高。



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



public class GradeLevel{
public static void main(String args[]){
System.out.println("\n**firstsituation**");
char grade='C';//normaluse
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**secondsituation**");
grade='A';//creat error without break statement
switch(grade){
case 'A':System.out.println(grade+"is85～100");
case 'B':System.out.println(grade+"is70～84");
case 'C':System.out.println(grade+"is60～69");
case 'D':System.out.println(grade+"is＜60");
default:System.out.println("inputerror");
} System.out.println("\n**thirdsituation**");
grade='B';//severalcasewithsameoperation
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("inputerror");
}
}
}




运行结果为

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语句的作用。

§2.10 循环语句

循环语句的作用是反复执行一段代码，直到满足终止循环条件为止，一个循环一般应包括四部分内容：

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

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

3.迭代部分(iteration)：这是在当前循环结束，下一次循环开始执行的语句，常常用来使计数器加1或减1。

4.终止部分(termination)：通常是一个布尔表达式，每一次循环要对该表达式求值，以验证是否满足循环终止条件。

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

while语句

while语句实现"当型"循环，它的一般格式为：

[initialization]
while (termination){
body;
[iteration;]
}

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

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

do-while语句

do-while语句实现"直到型"循环，它的一般格式为：

[initialization]
do{
body;
[iteration;]
}while (termination);

1.do-while语句首先执行循环体，然后计算终止条件，若结果为true，则循环执行大括号中的语句，直到布尔表达式的结果为false。

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

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.初始化、终止以及迭代部分都可以为空语句(但分号不能)，三者均为空的时候，相当于一个无限循环。

举例:

public class Sum{
public static void main(String args[]){
System.out.println("\n**while循环语句！**");
int n=10,sum=0;//initialization 初始化
while(n>0){//termination终止条件
sum+=n;//body循环体
n--;//iteration 条件变量改变
}
System.out.println("和是："+sum);
System.out.println("\n**do_while循环语句**");
n=0;
sum=0;
do{
sum+=n;//body
n++;//iteration
}while(n<=10);//termination
System.out.println("和是："+sum);
System.out.println("\n**forstatement**");
sum=0;
for(int i=1;i<=10;i++){
//initialization，termination，iteration
sum+=i;
}
System.out.println("和是："+sum);
}
}



结果：

**while循环语句！**
和是：55

**do_while循环语句**
和是：55

**forstatement**
和是：55


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

public class PrimeNumber{
public static void main(String args[]){
System.out.println("** 100 到 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 newline
if(n<10)//after 10 numbers
continue;
System.out.println();
n=0;
}
System.out.println();
}
}



结果：

** 100 到 200之间的质数**
101 103 107 109 113 127 131 137 139 149
151 157 163 167 173 179 181 191 193 197
199

§2.11 转移语句

带标号的语句格式

标号: 语句
statementName: someJavaStatement;

break语句

不带标号的break语句: 终止当前语句的执行而使控制转移到当前语句的下一条语句.
带标号的break语句: 终止带标号的语句而使控制转移到带标号语句的下一条语句.
break statementName;

continue语句

只能用在循环语句中.


1.不带标号的continue语句: 无条件使控制转移到循环语句的条件判定部分.

continue语句用来结束本次循环，跳过循环体中下面尚未执的语句，接着进行终止条件的判断，以决定是否继续循环。对于for语句，在进行终止条件判断前，还要先执行迭代语句。它的格式为：

continue;

2.带标号的continue语句: 无条件使控制转移到带标号的循环语句的条件判定部分.

也可以用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++；然后开始下一次循环

Return语句

结束当前方法的执行并返回到调用方法语句的下一条语句.
return expression;
return;


[b]资料来源：http://blog.sina.com.cn/s/blog_4e5b83c001000cd6.html[/b][quote][/quote]