Java 2：运算符、表达式和语句

2.1 运算符与表达式

Java提供了丰富的运算符，如算术运算符、关系运算符、逻辑运算符、位运算符等。Java语言中的绝大多数运算符和C语言相同，基本语句如条件分支语句，循环语句等，也和C语言类似。

2.1.1算术运算符与算术表达式

1.加减运算符

加减运算符+、-是二目运算符，即连接两个操作元的运算符。加减运算符的结合方向是从左到右。例如2+3-8，先计算2+3，然后再将得到的结果减8.加减运算符的操作元实证性或浮点型数据，加减运算符的优先级是4级。

2.乘除和求余运算符

乘除和求余运算符*、/、%是二目运算符，结合方向是从左到右，例如2*3/8，先计算2*3，然后再将得到的结果除以8。乘除和求余运算符的操作元是整型或浮点型数据，*、/、%运算符的优先级是3级。

用算术运算符和括号连接起来的符合Java语法规则的式子，称为算术表达式。

2.1.2 自增、自减运算符

自增、自减运算符++、--是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或浮点型变量，作用是使变量的值增1或减1，例如：

++x(--x)表示在使用x之前，先使x的值增（减）1。

x++(x-0)表示在使用x之后，使x的值增（减）1。

粗略来看，++x和x++的作用相当于x=x+1。但++x和x++的不同指出在于，++x实现执行x=x+1再使用x的值，而x++是先使用x的值再执行x=x+1。如果x的原值是5，则对于“y=++x;”，y的值为6，对于“y=x++;”，y的值为5。

2.1.3 算术混合运算的精度

精度从“低”到“高”排列的顺序是：

byte    short    char   int     long   float   double

Java在计算算术表达式的值时，使用下列运算精度规则：

1. 如果表达式中有双精度浮点数（double型数据），则按双精度进行运算。例如，表达式5.0/2+10的结果12.5是double型数据。
2. 如果表达式中最高精度是单精度浮点数（float型数据），则按单精度进行运算，例如，表达式5.0f/2+10的结果12.5是float型数据。
3. 如果表达式中最高精度是long型整数，则按long精度进行运算。例如，表达式12L+100+’a’的结果2009是long型数据。
4. 如果表达式中最高精度低于int型整数，则按int精度进行运算。例如，表达式(byte)10+’a’的结果是1007，都是int型数据。

Java允许把不超过byte、short、char的取值范围的算术表达式的值赋给byte、short和char型变量。例如，(byte)30+’a’是结果为127的int型变量。

byte x=(byte)20+'a';

是正确的，但

byte x=(byte)30+'a';

却无法通过编译，编译错误是“可能损失精度，找到int需要byte”，其原因是(byte)30+’b’的结果是int型变量，其值超过了byte变量的取值范围。

2.1.4 关系运算符与关系表达式

关系运算符是二目运算符，用于比较两个值的关系。关系运算符的运算结果是boolean型，当运算符对应的关系成立时，运算结果时true，否则false。例如，10<9的结果是false，5>1的结果是true，3！=5的结果是true，10>20-17的结果为true。

结果为数值型的变量或表达式可以通过关系运算符形成关系表达式。

2.1.5 逻辑运算符与逻辑表达式

逻辑运算符包括&&，||，！。其中&&、||为二目运算符，实现逻辑与、逻辑或；！为单目运算符，实现逻辑非。逻辑运算符的操作元必须是boolean型数据，逻辑运算符可以用来连接关系表达式。

结果为boolean型的变量或表达式可以通过逻辑运算符型岑那个逻辑表达式。

逻辑运算符&&和||也称作短路逻辑运算符，这是因为op1的值是false时，&&运算符子啊进行运算时不再去计算op2的值，直接就得出op1&&op2的结果时false；当op1的值为true时，||运算符在进行运算时不再去计算op2的值，直接就得到op1||op2的结果时true。

2.1.6 赋值运算符与赋值表达式

赋值运算符=是二目运算符，左面的操作元必须是变量，不能是常量或表达式。设x是一个整型变量，y是一个boolean型变量，x=20和y=true都是正确的赋值表达式，赋值运算符的优先级较低，是14级，结合方向是从右往左。

赋值表达式的值就是=左面变量的值。例如：假如a、b是两个int型变量，那么表达式b=12和a=b=100的值分别为12和100。

注意不要将赋值运算符=与等号关系运算符==混淆。

2.1.7 位运算符

整型数据在内存中以二进制的形式表示，例如一个int型变量在内存中占用4个字节共32位，int型数据7的二进制表示是：

00000000000000000000000000000111

左面最高位是符号位，最高位是0表示正数，是1表示负数。负数采用补码表示，例如，-8的补码表示是：

11111111111111111111111111111000

这样就可以对两个整型数据实施位运算，即对两个整型数据对应的位进行运算得到一个新的整型数据。

1.按位与运算

按位与运算符&是双目运算符，对两个整型数据a、b按位进行运算，运算结果是一个整型数据c。运算法则是：如果a、b两个数据对应位都是1，则c的该位是1，否则为0.如果b的精度高于a，那么结果c的精度和b相同。

2.按位或运算

按位或运算符|是二目运算符，对两个整型数据a、b按位进行运算，运算结果是一个整型数据c。运算法则是：如果a、b两个数据对应位都是0，则c的该位是0，否则是1.如果b的精度高于a，那么结果c的精度和b相同。

3.按位非运算

按位非运算符~是单目运算符，对一个整型数据a按位进行运算，运行结果是一个整型数据c。运算法则是：如果a对应位是0，则c的该位是1，否则为0。

4.按位异或运算

按位异或运算符^是一个二目运算符，对两个整型数据a、b按位进行运算，运算结果是一个整型数据c。运算法则是：如果a、b两个数据对应位相同，则c的该位是0，否则是1。如果b的精度高于a，那么结果c的精度和b相同。

由异或运算法则可知：a^a=0,a^0=a。

因此，如果c=a^b，那么a=c^b，也就是说，^的逆运算仍然是^，即a^b^b等于a。

位运算符也可以操作逻辑型数据，法则是：

当a、b都是true时，a&b是true，否则是false。

当a、b都是false时，a|b是false，否则是true。

当a是true时，~a是false；当a是false时，~a是true。

位运算符在操作逻辑型数据时，与逻辑运算符&&、||、！不同的是：位运算符要计算完成a和b的值之后再给出运算的结果。

例：

public class Main {public static void main(String[] args) {char a1='+',a2='点',a3='进',a4='攻';char secret='A';a1=(char)(a1^secret);a2=(char)(a2^secret);a3=(char)(a3^secret);a4=(char)(a4^secret);System.out.println("密文："+a1+a2+a3+a4);a1=(char)(a1^secret);a2=(char)(a2^secret);a3=(char)(a3^secret);a4=(char)(a4^secret);System.out.println("原文："+a1+a2+a3+a4);//密文：j烸辚敺//原文：+点进攻}
}

2.1.8 instanceof运算符

该运算符是二目运算符，左面的操作元是一个对象，右面是一个类。当左面的对象是右面的类或子类创建的对象时，该运算符运算的结果时true，否则是false（后面会详细讲解）。

2.1.9 运算符综述

Java表达式就是用运算符连接起来的符合Java规则的式子。运算符的优先级决定了表达式中运算执行的先后顺序。没必要去记忆运算符的优先级别，在编写程序时尽量地使用括号()运算符号来实现想要地运算次序。

2.2 语句概述

Java里的语句分为以下6类：

1.方法调用语句

如：

System.put.println("hello")

2.表达式语句

由一个表达式构成一个语句，即表达式尾加上分号。例如赋值语句：

x=23;

3.复合语句

可以用{}把一些语句括起来构成复合语句，例如：

{z=123+x;System.out.println("How are you");}

4.空语句

一个分号就是一个语句，称为空语句。

5.控制语句

控制语句分为条件语句、开关语句和循环语句。

6.package语句和import语句

package语句和import语句与类、对象有关。

2.3 if条件分支语句

条件分支语句按语法格式可细分尾三种形式，以下是这三种形式的详细讲解。

2.3.1 if语句

if语句是单条件分支语句，即根据一个条件来控制程序执行的流程。

if语句的语法格式：

if(表达式){若干语句
}

在if语句中，关键字if后面的一对小括号()内的表达式的值必须是boolean类型，当值尾true时，则执行紧跟着的复合语句，结束当前if语句的执行；如果表达式的值为false，结束当前if语句的执行。

需要注意的是，在if语句中，其中的复合语句中如果只有一条语句，{}可以省略不写，但为了增强程序的可读性最好不要省略（这是一个很好的编程风格）。

例：将变量a、b、c中的数值大小顺序进行互换（从小到大排列）

import java.util.Scanner;
public class Main {public static void main(String[] args) {int a=9,b=5,c=7,t=0;if(b<a){t=a;a=b;b=t;}if(c<a){t=a;a=c;c=t;}if(c<b){t=b;b=c;c=t;}System.out.println("a="+a+",b="+b+",c="+c);//a=5,b=7,c=9}
}

2.3.2 if-else语句

if-else语句是单条件分支语句，即根据一个条件来控制程序执行的流程。

if-else语句的语法格式：

if(表达式) {若干语句
}
else{若干语句
}

在if-else语句中，关键字if后面的一对小括号()内的表达式的值必须是boolean类型，当值为true时，则执行紧跟着的复合语句，结束当前if-else语句的执行；如果表达式的值为false，则执行关键字else后面的复合语句，结束当前if-else语句的执行。

下面是有语法错误的if-else语句。

if(x>0)y=10;z=20;
elsey=-100;

正确的写法是：

if(x>0){y=10;z=20;
}
elsey=100;

需要注意的是，在if-else语句中，其中的复合语句中如果只有一条语句，{}可以省略不写，但为了增强程序的可读性最好不要省略（这是一个很好的编程风格）。

例：写两个if-else语句，其作用是根据成绩输出相应的信息。

import java.util.Scanner;
public class Main {public static void main(String[] args) {int math=65,english=85;if(math>60){System.out.println("数学及格了");}else{System.out.println("数学不及格");}if(english>90){System.out.println("英语是优");}else{System.out.println("英语不是优");}System.out.println("我在学习if-else语句");}
}

2.3.3 if-else if-else语句

if-else if-else语句是多条件分支语句，即根据多个条件来控制程序执行的流程。

if-else if-else语句的语法格式：

if(表达式){若干语句
}
else if(表达式){若干语句
}
.
.
.
else{若干语句
}

在if-else if-else语句中，if以及多个else if后面的一对括号()内的表达式的值必须是boolean类型。程序执行if-else if-else时，按该语句中表达式的顺序，首先计算第一个表达式的值，如果计算结果为true，则执行紧跟着的复合语句，结束当前if-else if-else语句的执行，如果计算结果false，则继续计算第二个表达式的值，依此类推，假设计算第m个表达式的值为true，则执行进根着的复合语句，结束之前if-else if -else语句的执行，否则继续计算第m+1个表达式的值，如果所有表达式的值都是false，执行关键字else后面的复合语句，结束当前if-else if-else语句的执行。

if-else if-else语句中的else部分是可选项，如果没有else部分，当所有表达式的值都是false时，结束当前if-else if-else语句的执行（该语句什么都没有做）。

需要注意的时，在if-else if-else语句中，其中的复合语句中如果只有一条语句，{}可以省略不写，但为了增强程序的可读性最好不要省略。

2.4 switch开关语句

switch语句是单条件多分支的开关语句，它的一般格式定义如下（其中break语句是可选的）。

switch(表达式)
{case 常量值1:若干个语句break;case 常量值2:若干个语句break;...case 常量值n:若干个语句break;default:若干语句

switch语句中“表达式“的值可以是byte、short、int、char型；“常量值1”到“常量值n”也是byte、short、int、char型，而且要互不相同。

switch语句首先计算表达式的值，如果表达式的值和某个case后面的常量值相等，就执行该case里的若干语句直到碰到break语句为止。如果某个case中没有使用break语句，一旦表达式的值和该case后面的常量值相等，程序不仅执行该case里的若干语句，而且继续执行后继case里的若干个语句，直到碰到break语句为止。若switch语句中的表达式的值不与任何case的常量值相等，则执行default后面的若干个语句。switch语句中的default是可选的，如果它不存在，并且switch语句中表达式的值不与任何case的常量值相等，那么switch语句就不会进行任何处理。

几个分支语句的共同特点是根据一个条件选择执行一个分支操作，而不是选择执行多个分支操作。在switch语句中，通过合理地使用break语句，可以达到根据一个条件选择执行一个分支操作（一个case）或多个分支操作（多个case）地结果。

例：使用switch语句判断用户从键盘输入地正整数是否为中奖号码。

import java.util.Scanner;
public class Main {public static void main(String[] args) {int number=0;System.out.println("输入正整数（回车确定）");Scanner reader=new Scanner(System.in);number=reader.nextInt();switch(number){case 9:case 131:case 12:System.out.println(number+"是三等奖");break;case 209:case 596:case 27:System.out.println(number+"是二等奖");break;case 875:case 316:case 59:System.out.println(number+"是一等奖");break;default:System.out.println(number+"不中奖");}}
}

需要情调地是，switch语句中表达式地值是byte、short、int、char型，但不可以是long型数据。如果将例子4中的

int number=0;

更改为：

long number=0;

将导致编译错误。

2.5 循环语句

循环语句是根据条件，要求程序反复执行某些操作，直到程序“满意”为止。

2.5.1 for循环语句

for语句的语法格式：

for(表达式1;表达式2;表达式3){若干语句
}

for语句由关键字for、一对小括号()中用分号分隔的三个表达式，以及一个复合语句组成，其中的表达式2必须是一个求值为boolean型数据的表达式，而复合语句称为循环体。循环体只有一条语句时，大括号可以省略，但最好不要省略，以便增加程序的可读性。表达式1负责完成变量的初始化；表达式2是值为boolean型的表达式，称为循环条件；表达式3用来修整变量，改变循环条件。for语句的执行规则是：

1. 计算表达式1，完成必要的初始化工作。
2. 判断表达式2的值，若表达式2的值为true，则进行（3），否则进行（4）。
3. 执行循环体，然后计算表达式3，以便改变循环条件，进行（2）。
4. 结束for语句的执行。

例：计算8+88+888+8888+…的前12项和

public class Main{public static void main(String[] args) {long sum=0,a=8,item=a,n=12,i=1;for(i=1;i<=n;i++) {sum=sum+item;item*=item*10+a;}}
}

2.5.2while循环语句

while语句的语法格式：

while(表达式){若干语句
}

while语句由关键字while、一对括号()中的一个求值为boolean类型数据的表达式和一个复合语句组成，其中的复合语句称为循环体，循环体只有一条语句时，大括号{}可以省略，但最好不要省略，以便增加程序的可读性。表达式称为循环条件。while语句的执行规则是：

1. 计算表达式的值，如果该值是true时，就进行（2），否则执行（3）。
2. 执行循环体，再进行（1）.
3. 结束while语句的执行。

2.5.3 do-while循环语句

do-while循环语法格式如下：

do {若干语句
}while(表达式);

do-while循环和while循环的区别是do-while的循环体至少被执行一次。

例：用while语句计算1+1/2！+1/3！+1/4！+…的前20项和

public class Main{public static void main(String[] args){double sum=0,item=1;int i=1,n=20;while(i<=n){sum+=item;i+=1;item=item*(1.0/1);}System.out.print(“sum=”=sum);}
}

2.6 break和continue语句

break和continue语句是用关键字break和continue加上分号构成的语句，例如：

break;

在循环体中可以使用break语句和continue语句。在一个循环中，例如循环50次的循环语句中，如果在某次循环中执行break语句，那么整体循环语句就结束。如果在某次循环中执行了continue语句，那么本次循环就结束，即不再执行本次循环中循环体中的continue语句后面的语句，而转入进行下一次循环。

例：使用了break和continue语句

public class Main{public static void main(String [] args){int sum=0,i,j;for(i=1;i<=10;i++){if(i%2==0){//计算1+3+5+7+9continue;}sum+=i;}System.out.println("sum+"+sum);for(j=2;j<=100;j++){//求100以内的系数for(i=2;i<=j/2;i++){if(j%i==0){break;}}if(i>j/2){System.out.println(" "+j+"是素数");}//sum+25// 2是素数// 3是素数// 5是素数// 7是素数// 11是素数// 13是素数// 17是素数// 19是素数// 23是素数// 29是素数// 31是素数// 37是素数// 41是素数// 43是素数// 47是素数// 53是素数// 59是素数// 61是素数// 67是素数// 71是素数// 73是素数// 79是素数// 83是素数// 89是素数// 97是素数}}
}

2.7 for语句及数组

for语句的功能给予扩充、增强，以便更好地遍历数组。调用格式如下：

for(声明循环变量:数组的名字){...
}

其中，声明的循环变量的类型必须和数组的类型相同。这种形式的for语句类似自然语言中的“for each”语句，为了便于理解上述for语句，可以将这种形式的for语句翻译为“对于循环变量依次取数组的每一个元素的值”。

例：分别使用for语句的传统方式和改进方式遍历数组

public class Main{public static void main(String[] args){int a[]={1,2,3,4};char b[]={'a','b','c','d'};for(int n=0;n<a.length;n++){//传统方式System.out.println(a[n]);}for(int n=0;n<b.length;n++){//传统方式System.out.println(b[n]);}for(int i:a){//循环变量i依次取数组a的每一个元素的值（改进方式）System.out.println(i);}for(char ch:b){//循环变量ch依次取数组b的每一个元素的值（改进方式）System.out.println(ch);}//1//2//3//4//a//b//c//d//1//2//3//4//a//b//c//d}
}

需要特别注意的是：for(声明循环变量:数组的名字)中的“声明循环变量”必须是变量声明，不可以使用已经声明过的变量。例如，上述例子中第三个for语句不可以如下分开写成一条变量声明和一条for语句：

int i=0;//变量声明
for(i:a) {//for语句System.out.println(i);
}