第3章运算符、表达式和语句

主要内容 
 运算符与表达式


视频讲解


 语句概述
 if条件分支语句
 switch开关语句
 循环语句
 break和continue语句
 for语句与数组



视频讲解


3.1运算符与表达式

Java提供了丰富的运算符，例如算术运算符、关系运算符、逻辑运算符、位运算符等。Java语言中的绝大多数运算符和C语言相同，基本语句（例如条件分支语句、循环语句等）也和C语言类似，因此
本章对主要知识点进行简单的介绍。
3.1.1算术运算符与算术表达式
 加减运算符

加减运算符+、-是二目运算符，即连接两个操作元的运算符。加减运算符的结合方向是从左到右。例如2+3-8，先计算2+3，
再将得到的结果减8。加减运算符的操作元是整型或浮点型数据，加减运算符的优先级是4级。
 乘、除和求余运算符
乘、 除和求余运算符*、/、%是二目运算符，结合方向是从左到右。例如2*3/8，先计算2*3，
再将得到的结果除以8。乘、除和求余运算符的操作元素是整型或浮点型数据，
乘、除和求余运算符的优先级是3级。

用算术运算符和括号连接起来的符合Java语法规则的式子称为算术表达式。例如x+*y-30+3*(y+5)。
 3.1.2自增、自减运算符

自增、自减运算符++、- -是单目运算符，可以放在操作元素之前，也可以放在操作元素之后。操作元素必须是一个整型或浮点型变量，作用是使变量的值增1或减1。例如，
++x(- -x)表示在使用x之前先使x的值增(减)1，
x++(x- -)表示在使用x之后使x的值增(减)1。
粗略地看，假如x是byte型，++x和x++的作用相当于x=(byte)(x+1)。++x和x++的不同之处在于，++x是先执行x=(byte)(x+1)再使用x的值，而x++是先使用x的值再执行x=(byte)(x+1)。如果x的原值是5，则对于“y=++x;”，y的值为6； 对于“y=x++;”，y的值为5。
 3.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'的结果209是long型数据。
(4) 如果表达式中的最高精度低于int型整数，则按int精度进行运算。例如，表达式(byte)10+'a'和5/2的结果分别为107和2，都是int型数据。
Java允许把不超出byte、short和char的取值范围的常量算术表达式的值赋给byte、short和char型变量。例如，(byte)30+'a'是结果为127的int型常量。


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



是正确的，但


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



无法通过编译，编译错误是“可能损失精度，找到int需要byte”，原因是(byte)30+'b'的结果是int型常量，其值超出了byte变量的取值范围(见上面
精度运算规划的第4条)。

需要特别注意的是，当赋值号右边的表达式中有变量时，编译只检查变量的类型，不检查变量中的值。例如，
“byte x=97+1;”和“byte y=1;”都是正确的，但是“byte z=97+y;”是错误的，其原因是编译器不检查表达式97+y中变量y的值，只检查y的类型，并认为表达式97+y的结果是int型精度(见上面精度运算规则的第4条)。所以，对于
“byte z=97+y;”，编译器会提示“不兼容的类型： 从int型转换为byte型可能会有损失”的信息。

 3.1.4关系运算符与关系表达式

关系运算符是二目运算符，用来比较两个值的关系。关系运算符的运算结果是boolean型，当运算符对应的关系成立时，运算结果是true，否则是false。例如，10<9的结果是false，5>1的结果是true，3!=5的结果是true，10>20-17的结果为true，因为算术运算符的级别高于关系运算符，10>20-17相当于10>(20-17)，其结果是true。

结果为数值型的变量或表达式可以通过关系运算符(如表3.1所示)形成关系表达式。例如4>8、(x+y)>80等。


表3.1关系运算符



运算符优先级用法含义结 合 方 向


>6op1>op2大于从左到右
<6op1<op2小于从左到右
续表



运算符优先级用法含义结 合 方 向


>=6op1>=op2大于或等于从左到右
<=6op1<=op2小于或等于从左到右
==7op1==op2等于从左到右
!=7op1!=op2不等于从左到右

 3.1.5逻辑运算符与逻辑表达式

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


表3.2逻辑运算符



运算符优先级用法含义结 合 方 向


&&

||

!11

12

2op1&&op2

op1||op2

!op逻辑与

逻辑或

逻辑非从左到右

从左到右

从右到左

结果为boolean型的变量或表达式可以通过逻辑运算符形成逻辑表达式。表3.3给出了用逻辑运算符进行逻辑运算的结果。


表3.3用逻辑运算符进行逻辑运算



op1op2op1&&op2op1||op2!op1


truetruetruetruefalse
truefalsefalsetruefalse
falsetruefalsetruetrue
falsefalsefalsefalsetrue

例如，2>8&&9>2的结果为false，2>8||9>2的结果为true。由于关系运算符的级别高于&&、||的级别，2>8&&8>2相当于(2>8)&&(9>2)。
逻辑运算符&&和||也称作短路逻辑运算符，这是因为当op1的值是false时，&&运算符在进行运算时不再去计算op2的值，直接就得出op1&&op2的结果是false； 当op1的值是true时，||运算符在进行运算时不再去计算op2的值，直接就得出op1||op2的结果是true。
 3.1.6赋值运算符与赋值表达式

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

赋值表达式的值就是=左面变量的值。例如，假如a、b是两个int型变量，那么表达式b=12和a=b=100的值分别是12和100。
注意不要将赋值运算符=与等号关系运算符==混淆。例如，12=12是非法的表达式，而表达式12==12的值是true。

需要注意的是，对于+=、*=、/=、-=缩略运算符，编译器自动将赋值符号右侧的表达式的值转换成左边变量所要求的类型，例如b+=120等同于b=(byte)(b+120)。
 3.1.7位运算符

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


00000000 00000000 00000000 00000111



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


111111111 111111111 1111111 11111000



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

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

c：  00000000000000000000000000000011
 按位或运算
按位或运算符|是二目运算符，对两个整型数据a、b按位进行运算，运算结果是一个整型数据c。运算法则是： 如果a、b两个数据对应的位都是0，则c的该位是0，否则是1。如果b的精度高于a，那么结果c的精度和b相同。
 按位非运算
按位非运算符~是单目运算符，对一个整型数据a按位进行运算，运算结果是一个整型数据c。运算法则是： 如果a对应
的位是0，则c的该位是1，否则是0。
 按位异或运算
按位异或运算符^是二目运算符，对两个整型数据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，否则a&b是false。
当a、b都是false时，a|b是false，否则a|b是true。
当a是true时，~a是false； 当a是false时，~a是true。

位运算符在操作逻辑型数据时与逻辑运算符&&、||、！不同的是： 位运算符要在计算完a和b的值之后再给出运算的结果。例如，x的初值是1，那么经过下列逻辑比较运算后


((y=1)==0))&&((x=6)==6));



x的值仍然是1，但是经过下列位运算之后


((y=1)==0))&((x=6)==6));





图3.1异或运算

x的值将是6。
在下面的例子1中，利用异或运算的性质对几个字符进行加密并输出密文，然后再解密，运行效果如图3.1所示。

例子1
Example3_1.java


public class Example3_1 {

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);

}

}



 3.1.8instanceof运算符
instanceof运算符是二目运算符，左面的操作元是一个对象，右面是一个类。当左面的对象是右面的类或子类创建的对象时，该运算符运算的结果是true，否则是false(有关细节详见5.3.2节)。

 3.1.9运算符综述

Java表达式就是用运算符连接起来的符合Java规则的式子。运算符的优先级决定了表达式中运算执行的先后顺序。例如，x<y&&!z相当于(x<y)&&(!z)。大家没有必要去记忆运算符的优先级别，在编写程序时尽量地使用括号运算符()来实现想要的运算次序，以免产生难以阅读或含糊不清的计算顺序。运算符的结合性决定了并列的相同级别运算符的先后顺序。例如，加、减的结合性是从左到右，8-5+3相当于(8-5)+3； 逻辑否运算符！的结合性是从右到左，!!x相当于!(!x)。表3.4是Java中所有运算符的优先级和结合性，有些运算符和C语言中相同，这里不再赘述。


表3.4运算符的优先级和结合性



优先级描述运算符结合性


1分隔符［］、( )、.、，、;
2对象的归类，自增和自减运算，逻辑非instanceof、++、- -、！从右到左
3算术乘除运算*、/、%从左到右
4算术加减运算+、-从左到右
5移位运算>>、<<、>>>从左到右
6大小关系运算<、<=、>、>=从左到右
7相等关系运算==、!=从左到右
8按位与运算&从左到右
9按位异或运算^从左到右
10按位或运算|从左到右
11逻辑与运算&&从左到右
12逻辑或运算||从左到右
13三目条件运算?:从右到左
14赋值运算=从右到左



视频讲解


3.2语句概述
Java中的语句可分为以下6类。

 方法调用语句
例如： 


System.out.println("Hello");



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


x = 23;



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


{ z = 123+x;

System.out.println("How are you");

}



 空语句
一个分号也是一个语句，称作空语句。
 控制语句
控制语句分为条件分支语句、开关语句和循环语句，将在3.3~3.5节介绍。
 package语句和import语句
package语句和import语句与类、对象有关，将在第4章讲解。

3.3if条件分支语句


视频讲解


条件分支语句按语法格式可细分为3种形式，以下是这3种形式的详细讲解。
 3.3.1if语句
if语句是单条件、单分支语句，即根据一个条件来控制程序执行的流程。
if语句的语法格式为： 


if(表达式){

若干语句

}



if语句的流程图如图3.2所示。在if语句中，关键字if后面的一对小括号()内的表达式的值必须是boolean类型，当值为true时，执行

图3.2if单条件、单分支语句流程
紧跟着的复合语句，结束当前if语句的执行； 如果表达式的值为false，结束当前if语句的执行。


需要注意的是，在if语句中，其中的复合语句如果只有一个语句，{}可以省略不写，但为了增强程序的可读性
，最好不要省略(这是一个很好的编程习惯)。
在下面的例子2中，将变量a、b、c中的数值按大小顺序进行互换(从小到大排列)。
例子2
Example3_2.java


public class Example3_2 {

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);

}

}



 3.3.2ifelse语句
ifelse语句是单条件、双分支语句，即根据一个条件来控制程序执行的流程。
ifelse语句的语法格式为： 


if(表达式) {

若干语句

}

else {

若干语句

}



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


图3.3ifelse单条件、双分支语句流程


下面是有语法错误的ifelse语句： 


if(x>0)

y=10;

z=20;

else

y=-100;



正确的写法是： 


if(x>0){

y=10;

Z=20;

}

else

y=100;





图3.4使用ifelse语句

需要注意的是，在ifelse语句中，其中的复合语句如果只有一个语句，{}可以省略不写，但为了增强程序的可读性，最好不要省略(这是一个很好的编程习惯)。
在例子3中有两个ifelse语句，其作用是根据成绩输出相应的信息，运行效果如图3.4所示。

例子3
Example3_3.java


public class Example3_3 {

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语句");

}

}



 3.3.3ifelse ifelse语句

ifelse ifelse语句是多条件、多分支语句，即根据多个条件来控制程序执行的流程。
ifelse ifelse语句的语法格式为： 


if(表达式) {

若干语句

}

else if(表达式) {

若干语句

}

…

else {

若干语句

}




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



图3.5ifelse ifelse多条件、多分支语句流程


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

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


视频讲解


3.4switch开关语句
switch语句是单条件、多分支的开关语句，它的一般格式如下(其中break语句是可选的)。


switch(表达式)

{

case常量值1:

若干语句

break;

case常量值2:

若干语句

break;

…

case常量值n:

若干语句

break;

default:

若干语句

}



在switch语句中，“表达式”的值可以为byte、short、int、char和String类型(见8.1节)； “常量值1”到“常量值n”也是byte、short、int、char和String类型，而且要互不相同。

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

前面学习的分支语句(if语句、ifelse语句和ifelse ifelse语句)的共同特点是根据一个条件选择执行一个分支操作，而不是选择执行多个分支操作。在switch语句中，通过合理地使用break语句，可以达到根据一个条件选择执行一个分支操作(一个case)或多个分支操作(多个case)的结果。
下面的例子4使用了switch语句判断用户从键盘输入的正整数是否为中奖号码。
例子4
Example3_4.java


import java.util.Scanner;

public class Example3_4{

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;





视频讲解


将导致编译错误。
3.5循环语句
循环语句是根据条件要求程序反复执行某些操作，直到程序“满意”为止。
 3.5.1for循环语句
for语句的语法格式为： 


for (表达式1; 表达式2; 表达式3) {

若干语句

}



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

图3.6for循环语句流程
的表达式，称为循环条件； 表达式3用来修整变量，改变循环条件。for语句的执行规则如下： 


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

下面的例子5计算8+88+888+8888+…的前12项之和。
例子5
Example3_5.java


public class Example3_5 {

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;

}

System.out.println(sum);

}

}



 3.5.2while循环语句
while语句的语法格式为： 


while(表达式) {

若干语句

}



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

(1) 计算表达式的值，如果该值是true，就进行(2)，否则进行(3)。
(2) 执行循环体，再进行(1)。
(3) 结束while语句的执行。
while语句的执行流程如图3.7所示。

 3.5.3dowhile循环语句
dowhile循环语句的语法格式为： 


do{

若干语句

}while(表达式);



dowhile循环和while循环的区别是dowhile的循环体至少被执行一次，执行流程如图3.8所示。


图3.7while循环语句流程




图3.8dowhile循环语句流程



下面的例子6用while语句计算1+12!+13!+14!+…的前20项之和。
例子6
Example3_6.java


public class Example3_6 {

public static void main(String args［］) {

double sum = 0,item = 1;

int i = 1,n = 20;

while(i<=n) {

sum = sum+item;

i = i+1;

item = item*(1.0/i);

}

System.out.println("sum="+sum);

}

}





视频讲解


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


break;



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


public class Example3_7 {

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+9

continue;

}

sum=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+"是素数");

}

}

}

}



3.7for语句与数组


视频讲解


JDK 5对for语句的功能给予了扩充、增强，以便用户更好地遍历数组。其语法格式如下： 


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

…

}




其中，声明的循环变量的类型必须和数组的类型相同。这种形式的for语句类似自然语言中的for each语句，为了便于读者理解上述for语句，可以将这种形式的for语句翻译成“对于循环变量依次取数组中的每一个元素的值”。
下面的例子8分别使用for语句的传统方式和改进方式遍历数组。
例子8
Example3_8.java


public class Example3_8 {

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);

}

}

}



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


int i = 0;//变量声明

for(i:a) {//for 语句

System.out.println(i);

}





视频讲解



3.8应用举例
在2.4节中介绍了Scanner类，可以使用该类创建一个对象：


Scanner reader=new Scanner(System.in);



然后reader对象调用下列方法，读取用户在命令行中输入的各种基本类型的数据： 
nextBoolean()、nextByte()、nextShort()、nextInt()、nextLong()、nextFloat()、nextDouble()。

上述方法在执行时都会阻塞，等待用户在命令行中输入数据并回车确认(知识点见2.4节)。例如，如果用户在键盘
中输入一个byte取值范围内的整数89，那么reader对象调用hasNextByte()、hasNextInt()、hasNextLong()以及hasNextDouble()返回的值都是true。需要注意的是，如果用户在键盘中输入带小数点的数字，例如12.34，那么reader对象调用hasNextDouble()返回的值是true，而调用hasNextByte()、hasNextInt()以及hasNextLong()返回的值都是false。
在从键盘输入数据时，经常让reader对象先调用hasNextXXX()方法等待用户在键盘输入数据，然后再调用nextXXX()方法获取用户输入的数据。
在下面的例子9中，用户在键盘依次输入若干数字，最后输入一个非数字字符序列结束整个输入操作
，

图3.9计算平均值
这些数字之间以及数字和最后的非数字序列之间需要用空白(例如空格或回行)分隔，然后按回车
确认，程序将计算出这些数的和以及平均值。效果如图3.9所示。
例子9
Example3_9.java


import java.util.*;

public class Example3_9 {

public static void main(String args［］){

Scanner reader = new Scanner(System.in);

double sum = 0;

int m = 0;

while(reader.hasNextDouble()){

double x = reader.nextDouble();

m = m+1;

sum = sum+x;

}

System.out.printf("%d个数的和为%f＼n",m,sum);

System.out.printf("%d个数的平均值是%f＼n",m,sum/m);

}

}



3.9小结
(1) Java提供了丰富的运算符，例如算术运算符、关系运算符、逻辑运算符、位运算符等。
(2) Java语言中常用的控制语句和C语言中的很相似。
(3) Java提供了遍历数组的循环语句。
3.10课外读物
课外读物均来自作者的教学辅助微信公众号javaviolin，扫描二维码即可观看、学习。
1. 爱情故事
2. 生命的千年时移势迁
3. Kaprekar数字黑洞



习 题 3
一、 判断题（题目叙述正确的，在括号中打√，否则打×）
1. 表达式10>20-17的结果是1。()
2. 表达式5/2的结果是2。()
3. 逻辑运算符的运算结果是boolean型数据。()
4. 关系运算符的运算结果是int型数据。()
5. 12=12是非法的表达式。()
6. 表达式2>8&&9>2的结果为false。()
7. while(表达式)...语句中的“表达式”的值必须是boolean型数据。()
8. 在while语句的循环体中，执行break语句的效果是结束while语句。()
9. 在switch语句中必须要有default选项。()
10. if语句中的条件表达式的值可以是int型数据。()
二、 单选题
1. 下列叙述正确的是（）。

A. 5.0/2+10的结果是double型数据
B. (int)5.8+1.0的结果是int型数据
C. '苹'+ '果'的结果是char型数据
D. (short)10+'a'的结果是short型数据
2. 下列代码中，（）替换程序中标注的【代码】会导致编译错误。


public class E{

public static void main(String args［］) {

int m=10,n=0;

while(【代码】) {

n++;

}

}

}



A. m-->0B. m++>0 
C. m=0D. m>100&&true
3. 对于Test.java，下列叙述正确的是（）。


public class Test {

public static void main(String args［］) {

boolean boo = false;

if(boo = true){

System.out.print("hello");

System.out.print("你好");

}

else {

System.out.print("ok");

System.out.print("yes");

}

}

}



A. 出现编译错误B. 程序的输出结果是hello你好
C. 程序输出的结果是okD. 程序输出的结果是okyes
4. 对于“int n=6789;”，表达式的值为7的是（）。
A.  n%10B.  n/10%10
C.  n/100%10D.  n/1000%10 
5. 下列代码中，（）替换程序中标注的【代码】会使得程序输出hello。


public class Test {

public static void main(String args［］) {

int m = 0;

if(【代码】){

System.out.println("您好");

}

else {

System.out.println("hello");

}

}

}



A. m-- <= 0B. ++m> 0 
C. m++ > 0D. --m < 0
6. 假设有“int x=1;”，下列代码中，（）将导致“可能损失精度，找到int需要char”这样的编译错误。
A. short t=12+'a'; B. char c ='a'+1;
C. char m ='a'+x;D. byte n ='a'+1;
三、 挑错题(A、B、C、D注释标注的哪行代码有错误？)
1.


public class Test {

public static void main(String args［］) {

byte b = 'a'; //A

int n =100;

char c = 65;//B

b = b;//C

b = b+1;//D

}

}



2.


public class Test {

public static void main(String args［］) {

char ch = '花';//A

byte n = -100;

ch = ch-ch;//B

n = n; //C

n = 127; //D

}

}



3.


public class Test {

public static void main(String args［］) {

int m =1000;

while(m > 100)//A

{

m = m--;//B

if (m == 600){ //C

continue;

m++; //D

}

}

}

}



四、 阅读程序题
1. 下列程序的输出结果是什么？


public class E {

public static void main(String args［］) {

char x='你',y='e',z='吃';

if(x>'A'){

y='苹';

z='果';

}

else

y='酸';

z='甜';

System.out.println(x+","+y+","+z);

}

}



2. 下列程序的输出结果是什么？


public class E {

public static void main(String args［］) {

char c = '＼0';

for(int i=1;i<=4;i++) {

switch(i) {

case 1:c = 'J';

System.out.print(c);

case 2:c = 'e';

System.out.print(c);

break;

case 3:c = 'p';

System.out.print(c);

default: System.out.print("好");

}

}

}

}



3. 下列程序的输出结果是什么？


public class E {

public static void main(String ［］args) {

int x = 1,y = 6;

while (y-->0) {

x--;

}

System.out.print("x="+x+",y="+y);

}

}



五、 编程题
1. 编写应用程序求1!+2!+…+10!。
2. 编写应用程序求100以内的全部素数。
3. 分别用dowhile和for循环计算1+1/2!+1/3!+1/4!+…的前20项之和。
4. 如果一个数恰好等于它的因子之和，则这个数称为完数。编写应用程序求1000之内的所有完数。
5. 编写应用程序，使用for循环语句计算8+88+888+…的前10项之和。
6. 编写应用程序，输出满足1+2+3+…+n<8888的最大正整数n。