Java表达式和流程控制

第三天：

教学任务：

完成第三章内容的讲解，共23个slide(63-83)。

目标： 1. 操作符；

2. 条件语句；

3. 循环语句；

------------------------------------------------------------

第三章： Expressions and Flow Control(63-83)

程序的基本功能是处理数据

程序用变量来表示数据；

程序中必须先定义变量才能使用；

定义变量是指设定变量的数据类型和变量的名字，Java语言要求变量遵循先定义，再初始化，然后使用的规则。

变量的使用有一个作用域的问题，作用域是指它的存在范围，只有在这个范围内，程序代码才能访问它。

其次，作用域决定了变量的生命周期。变量的生命周期是指从一个变量被创建并分配内存空间开始，到这个变

量被销毁并清除其所占用内存空间的过程。当一个变量被定义时，它的作用域就被确定了。按照作用域的不同，

变量可分为以下类型：

. 成员变量：在类中声明，它的作用域是整个类；

. 局部变量：在一个方法的内部或方法的一个代码块的内部声明。如果在一个方法内部声明，它的作用域是整个

方法；如果在一个方法的某个代码块的内部声明，它的作用域是这个代码块。代码块是指位于一对

大括号"{}"以内的代码。

. 方法参数：方法或者构造方法的参数，它的作用域是整个方法或者构造方法。

. 异常处理参数：和方法参数很相似，差别在于前者是传递参数给异常处理代码块，而后者是传递参数给方法或者

构造方法。异常处理参数是指catch(Exception e)语句中的异常参数"e"，它的作用域是紧跟着

catch(Exception e)语句后的代码块。

目的：1. 局部变量

1) 定义在方法的内部或方法的一个代码块的内部；



public void method1() {

int a = 0; //局部变量，作用域为整个method01方法；

{

int b = 0; //局部变量，作用域为所处的代码块；

b = a;

}

b = 20; //编译出错，b不能被访问；

}

2) 局部变量没有默认值，使用之前必须先初始化；

按照课件上讲解的内容进行介绍；

3) 生命周期(创建分配内存空间到销毁清除内存空间的过程)

public class Sample {

public int add() {

int addResult = 1;

addResult = addResult+2;

return addResult;

}

public int subtract() {

int subResult = 1;

subResult = subResult-2;

return subResult;

}

public static void main(String[] args) {

Sample s = new Sample();

s.add();//开始局部变量addResult的生命周期，位于Java栈区；

结束局部变量addResult的生命周期，退回到main方法；

s.add();//开始局部变量addResult的生命周期，位于Java栈区；

结束局部变量addResult的生命周期，退回到main方法；

}

}

调用Sample实例的add方法，开始局部变量addResult的生命周期，addResult位于Java栈区。

执行完毕Sample实例的add方法，结束局部变量addResult的生命周期，退回到main方法；

画内存图分析其中的过程；

2. 实例变量

1) 在类中声明，它的作用域是整个类；

class Test {

private int n1=0;

private int n2=0;

public int add() {

int result = n2 + n2;

return result;

}

}

2) 实例变量有默认值，使用之前可无须初始化；

按照课件上讲解的内容进行介绍；

3) 生命周期(创建分配内存空间到销毁清除内存空间的过程)

class Test {

private int n1=0;

private int n2=0;

public int add() {

int result = n2 + n2;

n1 = n1+1;

n2 = n2+2;

return result;

}

public static void main(String[] args) {

Test t1 = new Test();

Test t2 = new Test();



t1.add();

t1.add();

t2.add();

}

}

创建Test实例，开始实例变量n1,n2的生命周期，n1,n2位于堆区。

执行完毕Test类的main方法，结束Test实例及它的实例变量n1，n2的生命周期，卸载Sample类，Java虚拟机运行结束。

画内存图分析其中的过程；

3. 操作符

程序的基本功能就是处理数据，程序用变量来表示数据。任何编程语言都有自己的操作符，Java语言也不例外。操作符

能与相应类型的数据组成表达式，来完成相应的运算。



一般情况下，不用去刻意记住操作符的优先级，当不能确定操作符的执行顺序时，可以使用圆括号来显示指定运算顺序。

1) 赋值操作符：

= : int x=0,i=1,j=1;

*= : 这里的"-="由操作符"-"和"="复合而成，它等价于 a=a*b; 这种复合操作符能使程序变得更加简洁。

/= : a/=b 等价于 a=a/b;

%= : a%=b 等价于 a=a%b;

...

2) 比较操作符

> : 大于

>= : 大于等于

< : 小于

<= : 小于等于

以上操作符只适用于整数类型和浮点数类型；

int a=1,b=1;

double d=1.0;

boolean result1 = a>b; //result1的值为false;

boolean result2 = a<b; //result2的值为false;

boolean result3 = a>=d; //result3的值为true;

boolean result4 = a<=b; //result4的值为true;

instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型，右边是一个类

名或接口名。形式如下：

obj instanceof ClassName

或者

obj instanceof InterfaceName



例如：

String a = "zs";

System.out.println(a instance String); //输出true;

3) 相等操作符

== : 等于

!= : 不等于

既可以是基本类型，也可以是引用类型：

a. 基本类型：

int a=1,b=1;

float c=1.0f;

double d=1.0;

System.out.println(a==b); //输出true;

System.out.println(a==c); //输出true;

System.out.println(a==d); //输出true;

System.out.println(c==d); //输出true;



b. 引用类型：

这两个引用变量必须都引用同一个对象，结果才为true.

Student s1 = new Student("zs",25,100);

Student s2 = new Student("zs",25,100);

Student s3 = s1;

System.out.println(s1 == s2); //输出false;

System.out.println(s1 == s3); //输出true;

System.out.println(s2 == s3); //输出false;

4) 数学运算操作符



+ : 数据类型值相加或字符串连接;

a. 数据类型值相加；

int a=1+2; //a值为3;

double b=1+2; //b值为3.0;

double b=1+2.0; //c值为3.0;

b. 字符串连接；

System.out.println(1+2+"a"); //输出3a

System.out.println(1+2.0+"a"); //输出3.0a

System.out.println(1+2.0+"a"+true); //输出3.0atrue

System.out.println("a"+1+2); //输出a12

System.out.println(1+"a"+2); //输出1a2

/ : 整除, 如操作数均为整数，运算结果为商的整数部分

int a1=12/5; //a1变量的取值为2

int a2=13/5; //a2变量的取值为2

int a3=-12/5; //a3变量的取值为-2

int a4=-13/5; //a4变量的取值为-2

int a5=1/5; //a5变量的取值为0

double a6=12/5; //a6变量的取值为-2.0

double a7=12/5.0; //a7变量的取值为-2.4



% : 取模操作符, 如操作数均为整数，运算结果为商的整数部分

int a1=1%5; //a1变量的取值为1

int a2=13%5; //a2变量的取值为3

double a3=1%5; //a3变量的取值为1.0

double a4=12%5.1; //a4变量的取值为1.8000000000000007



5) 移位操作符

>> : 算术右移位运算，也称做带符号右移位运算。

int a1 = 12 >> 1; //a1变量的取值为6;

int a2 = 128 >> 2; //a2变量的取值为32;

int a3 = 129 >> 2; //a3变量的取值为32;

int a3 = 12 >> 33; //a3变量的取值为6;

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一位符号位，由于12是正整数，因此增加的符号位为0;

b. 对-12右移一位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二位符号位，由于-12是负整数， 因此增加的符号位为1;

c. 表达式" a>>b " 等价于： a/2^b%32

>>> : 逻辑右移位运算，也称为不带符号右移位运算。

int a1 = 12 >>> 1; //a1变量的取值为6;

int a2 = -12 >>> 2; //a2变量的取值为1073741821;

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一个0;

b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二个0;

<< : 左移位运算，也称为不带符号左移位运算。

int a1 = 12 << 1; //a1变量的取值为24;

int a2 = -12 << 2; //a2变量的取值为-48;

int a3 = 128 << 2; //a3变量的取值为512;

int a4 = 129 << 2; //a4变量的取值为516;

注：a. 对12左移一位的过程为：舍弃二进制数的开头一位，在二进制数的尾部增加一个0;

b. 对-12左移二位的过程为：舍弃二进制数的开头二位，在二进制数的尾部增加二个0;

6) 位运算操作符

& : 与运算，对两个操作元的每个二进制位进行与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;

| : 或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;

^ : 异或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1^1->0, 1^0->1, 0^1->1, 0^0->0;

两个值相同，为0， 不同为1；

~ : 取反运算, ~1->0, ~0->1;

7) 逻辑操作符



短路操作符，如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边

的布尔表达式；

&& : 左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。

|| : 左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。

8) 条件操作符

布尔表达式 ? 表达式1 : 表达式2

如果布尔表达式的值为true, 就返回表达式1的值， 否则返回表达式2的值。

int score = 61;

String result = score>=60?"及格":"不及格";

4. 类型转换

1) 使用在基本数据类型和实例对象之间的转换。

2) 隐式转换和显式转换

3) 隐式转换是在运行期间转换，从子类转换到父类。第五章会详细讲解。

4) 显式转换，缩小变化。

按书上课件一步步讲解；

5. 条件语句

有些程序代码只有满足特定条件的情况下才会被执行，Java语言支持两种条件处理语句：

1) if ... else

照书上讲的内容先讲if...else的语法。

a. if后面的表达式必须是布尔表达式，而不能为数字类型，例如下面的if(x)是非法的。

int x=0;

if(x) { //编译出错

System.out.println("x不等于0");

} else {

System.out.println("x等于0");

}

b. 假如if语句或else语句的程序代码块中包括多条语句，则必须放在大括号{}内。若程序代码块只有一条语句

则可以不用大括号{}。流程控制语句(如if...else语句)可作为一条语句看待。

public void amethod(int x) {

if(x>0)

System.out.println("x不等于0");

else

if(x==0)

System.out.println("等于0");

else if(x<0)

System.out.println("小于0");

}



课堂练习：1) 写一个方法实现分时问侯, 如是8点至12点，返回"上午好", 12点至14点，返回"中午好",

14点至18点，返回"下午好", 其它时间返回"晚上好"

public String sayHello(int hour) {

String msg;

if(hour >=8 && hour < 12)

msg = "上午好";

else if(hour>=12 && hour <14)

msg = "中午好";

else if(hour>=14 && hour <18)

msg = "下午好";

else

msg = "晚上好";



return msg;

}

2) 写一个方法判断某一年是否为闰年。

标准：1) 能被4整除，但不能被100整除;

或

2) 能被400整除；

/**实现方式一*/

public boolean isLeapYear(int year) {

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

return true;

else

return false;

}



//程序代码比较简洁，缺点是运行效率比较低

/**实现方式二*/

public boolean isLeapYear(int year) {

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;

return leap;

}

//结构比较清晰，运行效率也比较高

/**实现方式三*/

public boolean isLeapYear(int year) {

boolean leap;

if(year%4==0) {

if(year%100==0) {

if(year%400==0)

leap=true;

else

leap=false;

} else

leap=false;

} else

leap=false;

return leap;

}

2) switch

语法：switch(expr) {

case value1:

statements;

break;

...

case valueN

statments;

break;

default:

statements;

break;

}

a. expr的类型必须是byte, short, char或者int;

b. valuesN类型必须是byte, short, char或者int, 该值必须是常量。各个case子句的valueN值不同；

c. 当switch表达式的值不与任何case子句匹配时，程序执行default子句，假如没有default子句，则程序直接

退出switch语句。default子句可以位于switch语句中的任何位置。

d. 如果switch表达式与某个case表达式匹配，或者与default情况匹配，就从这个case子句或default子句开始执行。

假如遇到break，就退出整个switch语句，否则依次执行switch语句中后续的case子句，不再检查case表达式的值。

e. switch语句的功能也可以用if...else语句来实现。但switch语句会使程序更简洁，可读性更强。而if...else

功能更为强大。

课堂练习：1) 写一个方法，能实现数值星期和中文星期的转换，如0会转换为星期天, 1会转换为星期一。

public String switchWeekLabel(int week) {

String result;



switch(week) {

case 0:

result = "星期天";

break;

case 1:

result = "星期一";

break;

case 2:

result = "星期二";

break;

case 3:

result = "星期三";

break;

case 4:

result = "星期四";

break;

case 5:

result = "星期五";

break;

case 6:

result = "星期六";

break;

default:

result = "您输入的星期数值为"+week+",不能进行转换";

}

}

2) 写一个方法，返回指定月份最后一天到底是多少号？

public int getLastDay(int year, int month) {

int day=30;



switch(month) {

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

day=31;

break;

case 2:

day = getLeapYear(year)? 29:28;

}



return day;

}



5. 循环语句

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

. 初始化部分：用来设置循环的一些初始条件，比如循环控制变量的初始值；

. 循环条件： 这是一个布尔表达式，每一次循环都要对该表达式求值，以判断到底继续循环还是终止循环。

. 循环体： 这是循环操作的主体内容，可以是一条语句，也可以是多条语句；

. 迭代部分： 用来改变循环控制变量的值，从而改变循环条件表达式的值；

Java语言提供三种循环语句：for语句、while语句和do...while语句。for语句、while语句在执行循环体之前

测试循环条件，而do...while语句在执行循环体之后测试循环条件。因此for语句、while语句有可能连一次循

环都未执行，而do...while至少执行一次循环体。

1) for循环

语法：for(初始化部分；循环条件；迭代部分) {

循环体

}

在执行for语句时，先执行初始化部分，这部分只会被执行一次；

接下来计算作为循环条件的布尔表达式，如果为true，就执行循环体；

接着执行迭代部分，然后再计算作为循环条件的布尔表达式，如此反复；

课堂练习：1) 写一方法，完成计算从1加到100的和；

public int sum() {

int result = 0;

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

result = result + i;

}

return result;

}

2) 在练习一基础上，完成计算从1加到指定数值的和；



public int sum(int n) {

int result = 0;

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

result = result + i;

}

return result;

}



//注意部分可选讲解

注意： a. for语句的循环体只有一条语句，可以不用大括号；

b. 在for语句内声明的变量的作用域为当前for语句，不能在for语句以外的地方使用它。

c. 在初始化部分和迭代部分可以使用逗号语句(用逗号分隔的语句序列).

for(int i=0,j=1;i<10;i++,j--) {

...;

}

或

int j,k;

for(i=0,j=10;(i<10 && k>0); i++,k--) {...}

以下内容不对：

int i;

for(i=5,int j=10;i<10;j--) {} //i=5,int j=10不是合法的初始化语句



int i,k;

for(i=0,k=9;i<10,j>0;i++,j--) {} //i<10,j>0不是合法的布尔表达式

2) while循环

语法：[初始化部分]

while(循环条件) {

循环体,包括迭代部分

}

当循环条件为true时，就重复执行循环，否则终止循环；

课堂练习：1) 用while循环完成计算从1加到指定数值的和；



public int sum(int n) {

int result = 0,i=1;

while(i<=n) {

result = result + i;

i=i+1;

}

return result;

}

3) do ... while循环

和while非常类似，只不过先执行循环体，然后再判断循环条件。



语法：[初始化部分]

do {

循环体,包括迭代部分

} while(循环条件);

课堂练习：1) 用do...while循环完成计算从1加到指定数值的和；



public int sum(int n) {

int result = 0,i=1;

do {

result = result + i;

i=i+1;

} while(i<=n)

return result;

}

以上三种循环，功能类同。作为一种编程惯例，for语句一般用在循环次数事先可确定的情况下，则

while和do...while语句则用在循环次数事先不可确定的情况下。

课堂练习：往控制台上输出以下内容：



*

**

***

****

*****

******

*******

6. 循环语句中流程跳转

1) break: 终止当前或指定循环；

public int sum(int n) {

int result = 0,i=1;

while(i<=n) {

result = result + i;

i=i+1;

if(i>10)

break;

}

return result;

}



实现1加到10;

2) continue: 跳过本次循环，执行下一次循环，或执行标号标识的循环体。

public int sum(int n) {

int result = 0;

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

if(i%2==0)

continue;

result = result + i;

}

return result;

}

实现指定范围内奇数的和；

3) label: 标号用来标识程序中的语句，标号的名字可以是任意的合法标识符。

continue语句中的标识必须定义在while、do...while和for循环语句前面；

break语句中的标识必须定义在while、do...while和for循环语句或switch语句前面；

仔细讲解课件上例子。

7. 一个例子

这个例子涉及了我们后面课程的知识：数组、异常处理、final关键字等，所以暂时不讲。

课堂练习：1) 往控制台上输出以下内容：



*

**

***

****

*****

******

*******

public class Test {

public static void main(String[] args) {

int n=7;

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

for(int j=1;j<=n-i;j++) {

System.out.print(" ");

}

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

System.out.print("*");

}

System.out.println();

}

}

}

2) 往控制台上输出以下内容：



*

***

*****

*******

*********

***********

*************

public class Test {

public static void main(String[] args) {

int n=7;

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

for(int j=1;j<=n-i;j++) {

System.out.print(" ");

}

for(int j=1;j<=2*i-1;j++) {

System.out.print("*");

}

System.out.println();

}

}

}

3) 由软件产生一个1至100范围内的随机数，让客户猜、如猜中出现是否再玩下一局的提示，否则提示应该

猜高或猜低。

课后练习：1.(Level 1) What is the difference between instance variables and local variables?

答：1) 作用范围不同: 实例变量作用范围为整个类，局部变量为某个方法或方法内代码块；

2) 实例变量有默认值，可不能初始化便可使用；局部变量没有默认值，必须初始化后才能使用；

2.(Level 1) What is the difference between && and &?

答：&符号左右两边的表达式每次都必须执行，&&操作符左边表达式如返回值为false，右边表达式将不

进行处理；

3.(Level 2) What is the difference between switch/case and if/else?

答：switch语句的功能也可以用if...else语句来实现。假如流程分支的条件表达式类型为byte、short、

int, long，使用switch语句会使程序更简洁，可读性更强。而if...else 功能更为强大。

4.(Level 2) What is the difference between while and do loop?

答：while进入循环体之前必须符号循环条件，do第一次进入循环体之前无须满足循环条件;

5.(Level 2) After execution of the following code fragment, what are the values of the

variables x, a, and b?

1. Int X,a=6,b=7;

2. X=a++ + b++;

A. X=15,a=7,b=8;

B. X=15,a=6,b=7;

C. X=13,a=7,b=8;

D. X=13,a=6,b=7;

答：c

6. (Level 2) Which of the following expressions are legal?(choose all that apply)

A. int x=6; x=!x; //!不适用于int值

B. int x=6; if(!(x>3)) {} //

C. int x=6; x=~x

答：A, B

7. (Level 3) What results after compile and run the following code?

1. public class Conditional {

2. public static void main(String argd[]){

3. int x=4;

4 System.out.println(“value is: “+((x>4)?99.9:9));

5. }

6.}

A. value is 99.9

B. value is 9

C. value is 9.0

D. A compiler error at line 5

答：c