Java SE 第四节
流程控制语句
FlowControl Statement
数学上证明顺序结构、分支结构、循环结构是一个完备集。
1. 条件运算符(三元表达式),其形式为:
type d = a ? b : c; 具体化形式为:int d = 2 < 1 ? 3 : 4;
如果 a 为真,d = b ; 如果 a 为假, d = c ;
2. 轻量级的文本编辑器:UltraEdit、Editplus、vi、vim、gvim
3. 流程控制语句if的用法为:
第一种形式:
if(布尔表达式)
{
//待执行的代码
}
第二种形式:
if(布尔表达式)
{
//待执行的代码
}
else
{
//待执行的代码
}
第三种形式:
if(布尔表达式)
{
//待执行的代码
}
else if(布尔表达式)
{
//待执行的代码
}
else if(布尔表达式)
{
//待执行的代码
}
else
{
//待执行的代码
}
4. switch语句,使用形式为:
switch(变量) //此处的变量类型就目前所学内容来看,只能为4种
类型:byte,short, int, char。
{
case 常量1:
//待执行的代码
break;
case 常量2:
//待执行的代码
break;
case 常量3:
//待执行的代码
break;
default:
//待执行的代码
}
虽然case语句中的break是可选的,但在绝大多数情况下,如果没有break,程序的逻辑就会发生错误,因此,通常情况下都需要加上break。
If 语句可以代替switch,但后者不能代替前者,因为后者的变量类型受到限制。
5. Java中的循环控制语句一共有3种,分别是while,do… while以及for循环。
6. while循环,形式为:
while(布尔表达式)
{
//待执行的代码
}
7. do…while循环,新式为:
do
{
//待执行的代码
}
while(布尔表达式);
4. while与do…while之间的区别:如果布尔表达式的第一次判断就为false,那么while循环一次也不执行;do…while循环则会执行一次。如果布尔表达式第一次判断为true,那么while循环与do…while循环等价。
5. for循环(使用最多的一种循环),形式为:
for(变量初始化; 条件判断; 步进)
{
//待执行的代码
}
for循环的执行过程:
1)执行变量初始化。
2)执行条件判断。如果条件判断结果为假,那么退出for循环,开
始执行循环后面的代码;如果条件判断为真,执行for循环里面的代
码。
3)执行步进。
4)重复步骤2。
For循环初始化可以不写,但是分号必须保留,用以判断对应的是哪个项目
1. break语句:经常用在循环语句中,用于跳出整个循环,执行循
环后面的代码。
2. continue语句:经常用在循环语句中,用于跳出当前的这个循环
(或者是跳出本次循环),开始下一次循环的执行。
3. break与continue可以搭配标签使用,在实际开发中,根本没有人会将break与continue搭配标签来使用。
Java 分支语句
程序运行过程中,需要对运行的流程顺序做控制。基本上程序的执行过程分三种:
1.顺序执行
从开始到结束,依次运行代码,直至全部运行结束。
2.分支语句
在执行过程中,根据某些情况条件,只执行其中一部分语句代码
3.循环执行
在执行过程中,重复的执行某些语句代码。
我们先前做的那些示例练习,大部分都是顺序执行代码,这个是很自然熟悉的,也不需要特别的练习了,现在我们先看看分支语言如何来实现。
在现实世界中,很多这样的情况:如果今天下雨,就呆在家里看DVD,否则的话就出去打球。这样的选择题多得很。编程语言都来模拟这个逻辑,实现了条件分支i情况处理。
分支语句实现程序流程控制的功能 ,即根据一定的条件有选择地执行或跳过特定的语句。
Java分支语句分为两种:
if-else 语句:一种控制程序流程的最基本的方法,else子句可有可无;
switch 语句:另一种效率程序流程控制语句,当必须在程序中检测一个整型表达式的多个值时将会用到它。
下面我们首先来看if语句。
条件语句是最常用的一种分支语句,它的基本格式是:
if ( boolean expression ){
statement or block;
}
或者:
if ( boolean expression ){
statement or block;
} else if (boolean expression) {
statement or block;
} else {
statement or block;
}
在if后面的条件语句中,必须是一个可以转换成boolean 的表达式,这个表达式需要用括号括起来。
下面来看一个示例代码。
public class IfTest {
/**
* @param None
* @return Nothing
*/
public static void main(String args[]) {
int i;
i = 13;
System.out.println("*************************************");
if (i < 50) {
System.out.println("* The input number is less than 50! *");
} else if (i == 50) {
System.out.println("* The Input number is equal to 50! *");
} else {
System.out.println("*The input number is greater than 50*");
}
System.out.println("*************************************");
}
}
这个类非常简单,在它的main()方法中,定义了一个int类型的变量i,然后给i赋了一个值13。
在if分支语句中,根据这个i变量的取值向控制台打印不同的信息:如果i小于50,将执行分支i<50后的代码块,它向控制台输出“The Input number is less than 50!”;如果i等于50,将执行分支i==50后的代码块;如果i大于50,将执行分支i>50后的代码块。
在这个例子中,因为i的值等于13,它小于50,所以,将执行分支i<50代码块中的语句,它将向控制台输出如下的信息:
*************************************
* The input number is less than 50! *
*************************************
我们可以修改程序中的i的值,让它大于或者等于50,然后重新编译执行,看看输出的信息是否发生了变化。
在Java中,能够进行分支控制的语句,除了if以外,还有switch。
一个switch语句由一个控制表达式和一个由case标记描述的语句块组成。
和if不同,switch后面的控制表达式求出的值应该是整型而不是boolean类型,这点在初学时要尤为注意。从控制表达式的数据类型可以看出,if语句应用范围应该更为广泛常见,因为大部分的条件分值控制都是使用真假布尔运算来判断的,这在现实世界中也极为常见,比如前面的例子,今天的计划安排,是由天气情况来决定的,下雨,不下雨,很显然就是下雨情况的真假布尔判断。
可以这么说,switch能做的事情,if完全可以做到,你在写Java代码的时候,即使你不知道switch,也可以完成代码的编写。那么switch出现的意义是什么呢?
先别急,我们先把switch的用法搞清楚了。
switch语句对控制表达式求得的值,决定了哪一个case分支将被执行。每一个case都用唯一的常量表达式或常量来标示,用于控制这个case是否必须被执行。
程序将执行到那些表达式值与控制表达式的值相匹配的case分支中。如果不存在这样的匹配,则将执行default后面的代码块。如果没有default标记(并不推荐这样做),则控制被传递到switch块后的第一条语句,也就是退出了switch块。
控制表达式必须是可以转化为byte、short、char或int类型的值的表达式。实际上switch的控制表达式接收是int类型的值,之所以能接收byte、short、char型的值,用前面提到的数据类型隐式转换就可以明白了,是Java根据实际情况,岁这几种数据类型做了类型转换,因为long不允许隐式转化为int,所以不能直接使用long型的数据值。
注意在每一个case标记的代码块中,最后都有一个break语句。这条语句具有重大的作用,如果没有这条语句,当与case分支相连续的代码块执行完毕后,将会继续运行与下一个case 分支相联系的代码块。一般情况下这与我们的初衷不符,但是有的情况下,也可以结合这种特性,简化我们的代码。看下面的这个示例:
public class SwitchCase {
public static void main(String args[]) {
int n = 2;
int result;
switch (n + 1) {
case 1: {
System.out.println("Block A");
result = n;
break;
}
case 2: {
System.out.println("Block B");
result = n * n;
break;
}
case 3: {
System.out.println("Block C");
result = n * n * n;
break;
}
case 4: {
System.out.println("Block D");
result = n % 4;
break;
}
default:
result = 0;
}
System.out.println("n=" + n + " result=" + result);
}
}
在这个例子中,定义了一个整形变量n,并给它赋值2,在switch中,根据表达式“n+1”得到的整数值执行不同的代码块:1、2、3、4都定义了各自的执行方式,如果不是这些数,则将执行default中的语句,将变量“result”赋值为0。
编译并运行上面的程序,将得到如下的结果:
Block C
n=2 result=8
从执行结果中可以很清楚的看出,case 3后面的代码被执行了,它将result赋值为n*n*n运算后得到的值,也就是为2*2*2的值。
如果一个case分支打算执行与紧随其后的case语句相同的动作,那么在这个case分支中可以不用写任何的代码:
switch(expr){
case 0:
case 1:
statements;
break;
case 2:
… …
在这里,case 0分支会执行和case 1分支一样的操作。
case相对于switch处理逻辑的入口,上面的这个示例的写法,相当于把0与1的这两个入口合并为一个逻辑了。在实际的编码情况中,这点也很常见,比如大月与小月的判断,大家可以试着写写这个判断逻辑。
最后总的来说,switch可以看做是一种特殊情况下的if语句,用来编写更加清晰,简明的分支语句,如果你的逻辑分支判断都是等值判断,并且判断的条件多于3个以上的话,switch就是更好的选择了。
if语句可以不但的嵌套,在else之后,可以继续跟进if-else语句,来完成多个复合的布尔判断分支语句。就拿遥控器操作来说,如果你按1键,进入一频道,按2键,进入2频道,按音量增大键,进行音量调节增大操作,以此类推。如果那if来写,就会出现n个if-else嵌套,无论编写,还是阅读,都难于处理维护。
比如:
if(key==1){
//操作
}else if(key==2){
//操作
}else if(key==3){
//操作
}....
else{
//操作
}
现在代码量不大,看起来还可以接受。那么如果其中的注释操作,换成真正的操作的话,这段代码量就很可观了,到时候在一对if-else中间“遨游”,你就会对这种写法痛恨不已了。
如果换成switch呢?
switch(key){
case 1:
case 2:
case 3:
...
default:
}
当然不要忘了break处理,这样看起来,即使增加了处理逻辑代码,也比if-else看起来舒服多了吧。重点是代码的可读性和可维护性,这点在实际项目中是非常重要的。
循环语句的功能是在循环条件满足的情况下,反复执行一段代码,直到不再满足循环条件为止。
这个类型的工作恐怕是现在计算机最适合去做的事情之一了。无论哪个人在勤恳,重复做同样一件事情总是会新生倦怠的,这是谁也避免不了的。并且还不能保证重复做得每一次都是保证同样的质量和结果。
但是计算机就不同了,或者说机器就是不同了,它们非常适合做这类重复性的活动。
循环语句一般由下述四部分组成:
初始化部分(init_statement):一条或多条语句,用来做一些初始化工作,例如设置计数器初值等;
循环条件部分(test_exp):这是一个boolean类型的表达式,根据它的值来判断是否继续进行下一次循环;
循环体部分(body_statement):将被循环执行的目标代码,可以是一条语句,也可以是一个语句块;
迭代部分(alter_statement):在一次循环结束后,下一次循环开始前执行的语句,通常用于修改循环计数器的值。
循环语句使语句或块的执行得以重复进行。
Java编程语言支持三种循环构造类型:for, while和do while。三种循环结构均通过一个条件表达式来控制。
在while()和for()结构中,条件判断均先于语句块执行,所以,有可能语句块一次也不执行。
在do…while()中,语句块先于条件判断,所以,语句块至少执行一次。
这里先来看for循环的使用。
for语句的基本格式如下:
for ( init_expr ; boolean test_expr ; alter_expr){
statement or block;
}
其中:init_expr表示初始化代码,而test_expr是用于条件判断的表达式,如果表达式的值为true,则执行后面的语句,接下来进行后面的步进代码alter_expr。如果条件判断表达式test_expr第一次求值就为false,那么for循环不会进行任何的迭代,后面的statement也不会进行任何的操作。
程序执行遇到for语句时,首先执行初始化部分(init_statement)的语句,然后计算循环条件表达式test_exp的值,如为true,则执行循环体部分的语句(body_statement),否则结束循环。
一次循环结束后,下一次循环开始前,执行迭代部分的语句(alter_statement),然后判断循环条件表达式test_exp的值,决定是否进行下一次循环。
请看下面这个for循环的例子:
int result = 1;
for (int k = 5;k>1;k--) {
result = result * k;
}
上面这个程序片断的作用是实现一个简单的阶乘运算:n*(n-1)*(n-2)*…*1,在这里,n的值为5,因此,它运算的结果是5*(5-1)*(5-2)*(5-3)*(5-4)=5*4*3*2*1=120。
上面的例子中,init_expr只有一个初始化的值,条件判断表达式也只有一个条件,步进代码也是每次递减一个数字。但是,其实Java允许在for语句的循环控制的各个部分放置任何表达式,如下例:
for(int b = 0,s = 0,p = 0;(b<10)&&(s<4)&&(p<10);p++){
//代码块
//更新b和s 的值
}
在这个例子中,初始化的变量有三个,但是,只能有一个声明语句,所以,如果需要在初始化表达式init_expr中声明多个变量,那么这些变量必须是同一种数据类型的。
for循环并没有限制在它的for语句的每一部分都必须提供一个表达式,这三个部分其实都可以为空,此时,是一个无限的循环。这在语法上是没有错误的,只是这种循环在实际应用中会引起很多的问题,我们应该避免这种会引起无限循环的for语句。
下面来看一个例子,来了解一下for语句中各部分为空时的控制情况:
int sum=0;
//注意看这个for语句,它的步进部分是空的
for (int i=1;i<=n;){
sum=sum+i;
//将步进放到了for程序块中
i++;
}
注意这个for语句,它的步进部分是空的,我们将这个步进运算放到了程序块中。
一个无限for循环的例子如下:
for(;;){
//程序块
}
这种情况一般是要避免的,我们不应该让程序出现这种无限循环的情况。
在for语句内定义的变量,它的作用范围仅限于for语句块、表达式以及for子句的语句部分。在for循环终止后,它们将不可被访问。如果需要在for循环外部使用循环计数器的值,可以将这个变量定义在for循环体外,如下:
int k;
for(k = 0;k<10;k++){
//statements
}
//此时可以再使用变量k
另外,如果变量定义在for循环体内,则在另外一个循环体中还可以使用相同的变量名称,如下:
for(int k=0;k<10;k++) {
… …
}
for(int k = 100;k>0;k--) {
… …
}
上面的代码段是合法的。
while循环语句的格式:
init_statement
while ( boolean_expr ){
statement or block;
alter_expr;
}
while语句首先测试boolean_expr表达式的值,如果为true,则运行代码块中的程序,并且一般需要进行迭代运算,以改变boolean_expr表达式中的变量的值,直到表达式中的值变为false。
如果刚开始条件表达式就为false,则while循环永远也不会被执行。
来看一个while循环的例子:
… …
//while循环
int result1=0;
int result2=0;
//初始化一个变量
int i=1;
//利用这个变量构成一个条件表达式
while(i<=10) {
result1=result1+i;
//将i加1
i=i+1;
}
System.out.println("After the While Loop,the result1 is:"+result1);
… …
for循环和while循环是等价的,我们可以将如下的for循环:
for(init_expr;test_expr;alter_expr){
statements;
}
改写成如下的while循环方式:
init_expr;
while(test_expr){
statements;
alter_expr;
}
这两种方式是完全可以相互替换的。for循环和其他两个循环控制语句不同的地方在于,它可以在控制表达式中定义变量,而while/do…while不能这样做。
do…while循环语句的格式如下:
[init_expr]
do{
body_statement;
[alter_expr;]
}while( test_expr);
do…while循环类似于while循环,在while后面也得跟一个boolean类型的表达式。do…while循环首先执行里面的代码段,然后再根据test_expr判断是否为true,如果为true,则返回到do语句来执行,否则,退出整个循环。
因为do…while循环是先运行里面的代码块,然后再判断条件,所以,do…while循环至少会执行一次,这是do…while循环和while、for 循环最大的区别所在。
我们来看下面这个例子:
int result1=0;
int result2=0;
int j=1;
do {
result2=result2+j;
j=j+1;
}while(j<=10);
System.out.println("After the Do Loop,the result2 is:"+result2);
比较一下这个例子和上面while的例子,这两个例子中的test_expr都是一样的,但是,它们运行后得到的结果也是一样的。
在while循环中,得出的运算结果是55,而do…while得出的结果也是55。
但是,如果将各自的条件改成(i<=0)和(j<=0),则do…while循环将会返回一个1的结果,而while循环却只能返回一个0的结果,这就是因为do…while是“先执行,后判断”,而while却是“先判断,后执行”。
使用break语句可以终止switch语句和终止循环的子语句块,甚至是普通的程序块。关于如何终止switch语句,前面已经说过。这里主要说明如何来控制循环语句的执行。
1.break语句
在循环中,经常的,我们需要在某种条件出现时,强行终止循环的运行,而不是等到循环的判断条件为false时,这个时候,可以通过break来完成这个功能。
下面来看一个break的例子:
int sum1 = 0,n=10;
for (int i=1;i<=n;i++){
sum1=sum1+i;
if(i%2==0)break;
}
这个例子中,如果i能够被2整除,就跳出这个for循环。
因此,实际上,这个for循环只能循环两次,得到的sum1的值是3。
对于很多有C++或其他编程经验的读者,可能对于goto语句不会陌生,也可能曾经深受其困。在Java中,goto语句虽然是保留字,但并没有使用它。但在Java里也有类似goto的功能,这个功能和break以及continue结合。
在本质上而言,它和goto语句的跳跃是不同的,它是一种循环中断的方式而已。它和goto语句的相同点在于,它们都使用了标签(label)。
所谓标签(label),就是后面跟了一个冒号“:”的标识符,如:
oneLabel:
从语法上看,在Java程序中,标签可以放在任意的地方,但是,一般而言,标签只有放在循环语句之前,才能真正起到应有的作用,如下:
LableOne:
循环
{
… …
}
我们来看一个用在嵌套循环中的和标签结合的break例子:
outer:
for(int i = 0;i<10;i++) {
System.out.println("Outer loop:");
inner:
while(true) {
int k = System.in.read();
System.out.println("Inner Loop:"+k);
if(k=='b') break inner;
if(k=='q') break outer;
}
}
在这个例子中,从控制台接收一个输入,如果输入b,则退出内层的while循环,如果输入q则退出外层的循环(也就是终止整个循环)。
另外,如果需要终止普通的语句块(既不是switch也不是循环语句),则必须使用标签:
Label1:
{
Label2:
{
Lable 3:
{
…. …
}
}
}
2.continue语句
continue语句用来略过循环中剩下的语句,重新开始新的循环,这和break语句的完全跳出循环是不一样的。
continue 仅仅出现在while/do…while/for语句的子语句块中。
也可以使用和标签结合的方式来选择需要终止的嵌套循环的层级。
下面来看一个例子:
int sum1=0;
int sum2=0;
//Continue
for (int j=1;j<=10;j++) {
if(j%2==0)continue;
sum2=sum2+j;
}
System.out.println(sum2);
在这个例子中,如果在j可以被2整除,则不进行后面的相加操作,而重新返回到循环的开头
因此,它运算后的值为:25。完整的代码请参考示例4-11中的BreakAndContinue.java中的Continue部分。
在上一小节介绍break的时候,我们就提到过,在continue中也可以使用标签。
现在我们来看一个continue和标签结合的例子:
源文件:ContinueWithLabelDemo.java
public class ContinueWithLabelDemo {
public static void main(String[] args) {
String searchMe = "Look for a substring in me";
String substring = "subs";
boolean foundIt = false;
int max = searchMe.length() - substring.length();
test: for (int i = 0; i <= max; i++) {
int n = substring.length();
int j = i;
int k = 0;
while (n-- != 0) {
if (searchMe.charAt(j++) != substring.charAt(k++)) {
// 跳出的本次循环是for循环,而不是while循环
continue test;
}
}
foundIt = true;
// 跳出整个循环
break test;
}
System.out.println(foundIt ? "Found it" : "Didn't find it");
}
}
这个程序的作用是从字符串searchMe中搜索指定的子串substring,从要搜索的字符串substring(假设为“subs”)第一个子符开始去匹配searchMe的第一个字符,如果第一个字符都不匹配,就不用再比较第二个字符了(利用continue)。
如果第一个字符匹配,则比较第二个字符,如果第二个字符不匹配,则不用再往下比较,否则,往下比较第三个字符,依次类推。
如果找到完全匹配的子字符串,则退出整个循环(break)并且返回true。然后根据是否返回true打印出“Found it”或“Didn’t find it”。
如果substring的值为“subs”(如程序中所示),则会在控制台上打印出“Found it”,如果substring的值为“abc”,则会打印出“Didn’t find it”。