《Java从小白到大牛》之第7章 控制语句

《Java从小白到大牛》纸质版已经上架了！！！

程序设计中的控制语句有三种，即顺序、分支和循环语句。Java程序通过控制语句来管理程序流，完成一定的任务。程序流是由若干个语句组成的，语句可以是一条单一的语句，也可以是一个用大括号（{}）括起来的复合语句。Java中的控制语句有以下几类：

  • 分支语句：if和switch。
  • 循环语句：while、do-while和for
  • 跳转语句：break、continue、return和throw

7.1 分支语句

分支语句提供了一种控制机制，使得程序具有了“判断能力”，能够像人类的大脑一样分析问题。分支语句又称条件语句，条件语句使部分程序可根据某些表达式的值被有选择地执行。Java编程语言提供了if和switch两种分支语句。

7.1.1 if语句

由if语句引导的选择结构有if结构、if-else结构和else-if结构三种。

#####1. if结构

如果条件表达式为true就执行语句组，否则就执行if结构后面的语句。如果语句组只有一条语句，可以省略大括号，当从编程规范角度不要省略大括号，省略大括号会是程序的可读性变差。语法结构如下：


if (条件表达式) {
   语句组
}

if结构示例代码如下：

int score = 95;
if (score >= 85) {
    System.out.println("您真优秀！");
}
if (score < 60) {
    System.out.println("您需要加倍努力！");
}
if ((score >= 60) && (score < 85)) {
    System.out.println("您的成绩还可以，仍需继续努力！");
}

程序运行结果如下：

您真优秀！

#####2. if-else结构

所有的语言都有这个结构，而且结构的格式基本相同，语句如下：

if (条件表达式) {
   语句组1
} else {
   语句组2
}

当程序执行到if语句时，先判断条件表达式，如果值为true，则执行语句组1，然后跳过else语句及语句组2，继续执行后面的语句。如果条件表达式的值为false，则忽略语句组1而直接执行语句组2，然后继续执行后面的语句。

if-else结构示例代码如下：

int score = 95;
if (score < 60) {
    System.out.println("不及格");
} else {
    System.out.println("及格");
}

程序运行结果如下：

及格

#####3. else-if结构

else-if结构如下：

if (条件表达式1) {
    语句组1
} else if (条件表达式2) {
    语句组2
} else if (条件表达式3) {
    语句组3
...
} else if (条件表达式n) {
    语句组n
} else {
    语句组n＋1
}

可以看出，else-if结构实际上是if-else结构的多层嵌套，它明显的特点就是在多个分支中只执行一个语句组，而其他分支都不执行，所以这种结构可以用于有多种判断结果的分支中。

else-if结构示例代码如下：

int testScore = 76;
char grade;
if (testScore >= 90) {
    grade = ‘A‘;
} else if (testScore >= 80) {
    grade = ‘B‘;
} else if (testScore >= 70) {
    grade = ‘C‘;
} else if (testScore >= 60) {
    grade = ‘D‘;
} else {
    grade = ‘F‘;
}
System.out.println("Grade = " + grade);

输出结果如下：

Grade = C

其中char grade是声明字符变量，然后经过判断最后结果是C。

7.1.2 switch语句

switch提供多分支程序结构语句。下面先介绍一下switch语句基本形式的语法结构，如下所示：

switch (表达式) {
    case 值1：
        语句组1
    case 值2：
        语句组2
    case 值3：
        语句组3
            ...
    case 判断值n：
        语句组n
    default：
        语句组n＋1
}

switch语句中“表达式”计算结果只能是int、byte、short和char类型，不能是long更不能其他的类型。每个case后面只能跟一个int、byte、short和char类型的常量，default语句可以省略。

当程序执行到switch语句时，先计算条件表达式的值，假设值为A，然后拿A与第1个case语句中的值1进行匹配，如果匹配则执行语句组1，语句组执行完成后不跳出switch，只有遇到break才跳出switch。如果A没有与第1个case语句匹配，则与第2个case语句进行匹配，如果匹配则执行语句组2，以此类推，直到执行语句组n。如果所有的case语句都没有执行，就执行default的语句组n＋1，这时才跳出switch。

示例代码如下：

int testScore = 75;

char grade;
switch (testScore / 10) {           ①
case 9:
    grade = ‘优‘;
    break;
case 8:
    grade = ‘良‘;
    break;
case 7:          // 7是贯通的       ②
case 6:
    grade = ‘中‘;
    break;
default:
    grade = ‘差‘;
}
System.out.println("Grade = " + grade);

输出结果如下：

Grade = 中

上述代码将100分制转换为：“优”、“良”、“中”、“差”评分制，其中7分和6分都是“中”成绩，把case 7和case 6当成一种情况考虑。代码第①行计算表达式获得0~9分数值。代码第②行的case 7是贯通的，就它的后面不加break，程序流执行完当前case后，则会进入到下一个case，因此本来中case 7和case 6都执行相同的代码。

7.2 循环语句

循环语句能够使程序代码重复执行。Java支持三种循环构造类型：while、do-while、和for。for和while循环是在执行循环体之前测试循环条件，而do-while是在执行循环体之后测试循环条件。这就意味着for和while循环可能连一次循环体都未执行，而do-while将至少执行一次循环体。另外Java 5之后推出for-each循环语句，for-each循环是for循环的变形，它是专门为集合遍历而设计的，注意for-each并不是一个关键字。

7.2.1 while语句

while语句是一种先判断的循环结构，格式如下：

while (循环条件) {
    语句组
}

while循环没有初始化语句，循环次数是不可知的，只要循环条件满足，循环就会一直进行下去。

下面看一个简单的示例，代码如下：

int i = 0;
while (i * i < 100000) {
    i++;
}

System.out.println("i = " + i);
System.out.println("i * i = " + (i * i));

输出结果如下：

i = 317
i * i = 100489

上述程序代码的目的是找到平方数小于100000的最大整数。使用while循环需要注意几点，while循环条件语句中只能写一个表达式，而且是一个布尔型表达式，那么如果循环体中需要循环变量，就必须在while语句之前对循环变量进行初始化。本例中先给i赋值为0，然后在循环体内部必须通过语句更改循环变量的值，否则将会发生死循环。

7.2.2 do-while语句

do-while语句的使用与while语句相似，不过do-while语句是事后判断循环条件结构，语句格式如下：

do {
　　语句组
} while (循环条件)

do-while循环没有初始化语句，循环次数是不可知的，不管循环条件是否满足，都会先执行一次循环体，然后再判断循环条件。如果条件满足则执行循环体，不满足则停止循环。

下面看一个示例代码：

int i = 0;
do {
    i++;
} while (i * i < 100000);

System.out.println("i = " + i);
System.out.println("i * i = " + (i * i));

输出结果如下：

i = 317
i * i = 100489

该示例与上一节的示例是一样的，都是找到平方数小于100000的最大整数。输出结果也是一样的。

7.2.3 for语句

for语句是应用最广泛、功能最强的一种循环语句。一般格式如下：

for (初始化; 循环条件; 迭代) {
　　语句组
}

for语句执行流程如图7-1所示，首先会先执行初始化语句，它的作用是初始化循环变量和其他变量，然后程序会判断循环条件是否满足，如果满足，则继续执行循环体并计算迭代语句，之后再判断循环条件，如此反复，直到判断循环条件不满足时跳出循环。

以下示例代码是计算1~9的平方表程序：

System.out.println("---------");

for (int i = 1; i < 10; i++)  {
    System.out.printf("%d x %d = %d", i, i, i * i);
    //打印一个换行符，实现换行
    System.out.println();
}

输出结果如下：

---------
1 x 1 = 1
2 x 2 = 4
3 x 3 = 9
4 x 4 = 16
5 x 5 = 25
6 x 6 = 36
7 x 7 = 49
8 x 8 = 64
9 x 9 = 81

在这个程序的循环部分初始时，给循环变量i赋值为1，每次循环都要判断i的值是否小于10，如果为true，则执行循环体，然后给i加1。因此，最后的结果是打印出1~9的平方，不包括10。

提示 初始化、循环条件以及迭代部分都可以为空语句（但分号不能省略），三者均为空的时候，相当于一个无限循环。代码如下：**

for (; ;) {
    ...
}

另外，在初始化部分和迭代部分，可以使用逗号语句来进行多个操作。逗号语句是用逗号分隔的语句序列，如下程序代码所示：

int x;
int y;

for (x = 0, y = 10; x < y; x++, y--) {
    System.out.printf("(x,y) = (%d, %d)", x, y);
    // 打印一个换行符，实现换行
    System.out.println();
}

输出结果如下：

(x,y) = (0,10)
(x,y) = (1,9)
(x,y) = (2,8)
(x,y) = (3,7)
(x,y) = (4,6)

7.2.4 for-each语句

Java 5之后提供了一种专门用于遍历集合的for循环——for-each循环。使用for-each循环不必按照for的标准套路编写代码，只需要提供一个集合就可以遍历。

假设有一个数组，采用for语句遍历数组的方式如下：

// 声明并初始化int数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };

System.out.println("----for-------");
// for语句
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Count is:" + numbers[i]);
}

上述语句int[] numbers = { 43, 32, 53, 54, 75, 7, 10 }声明并初始化了10个元素数组集合，目前大家只需要知道当初始化数组时，要把相同类型的元素放到{…}中并且用逗号分隔（,）即可，关于数组集合会在后面第8章详细介绍。numbers.length是获得数组的长度，length是数组的属性，numbers[i]是通过数组下标访问数组元素。

那么采用for-each循环语句遍历数组的方式如下：

// 声明并初始化int数组
int[] numbers = { 43, 32, 53, 54, 75, 7, 10 };

System.out.println("----for each----");
// for-each语句
for (int item : numbers) {
    System.out.println("Count is:" + item);
}

从示例中可以发现，item不是循环变量，它保存了集合中的元素，的for-each语句将集合中的元素一一取出来，并保存到item中，这个过程中不需要使用循环变量，通过数组下标访问数组中的元素。可见for-each语句在遍历集合的时候要简单方便得多。

7.3 跳转语句

跳转语句能够改变程序的执行顺序，可以实现程序的跳转。Java有4种跳转语句：break、continue、throw和return。本章重点介绍break和continue语句的使用。throw和return将后面章节介绍。

7.3.1 break语句

break语句可用于上一节介绍的while、repeat-while和for循环结构，它的作用是强行退出循环体，不再执行循环体中剩余的语句。

在循环体中使用break语句有两种方式：带有标签和不带标签。语法格式如下：

break; //不带标签
break label; //带标签，label是标签名

不带标签的break语句使程序跳出所在层的循环体，而带标签的break语句使程序跳出标签指示的循环体。

下面看一个示例，代码如下：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

for (int i = 0; i < numbers.length; i++) {
    if (i == 3) {
        //跳出循环
        break;
    }
    System.out.println("Count is: " + i);
}

在上述程序代码中，当条件i==3的时候执行break语句，break语句会终止循环，程序运行的结果如下：

Count is: 0
Count is: 1
Count is: 2

break还可以配合标签使用，示例代码如下：

label1: for (int x = 0; x < 5; x++) {　          ①
    for (int y = 5; y > 0; y--) {               ②
        if (y == x) {
            //跳转到label1指向的循环
            break label1;   　           ③
        }
        System.out.printf("(x,y) = (%d,%d)", x, y);
        // 打印一个换行符，实现换行
        System.out.println();
    }
}
System.out.println("Game Over!");

默认情况下，break只会跳出最近的内循环（代码第②行for循环）。如果要跳出代码第①行的外循环，可以为外循环添加一个标签label1，注意在定义标签的时候后面跟一个冒号。代码第③行的break语句后面指定了label1标签，这样当条件满足执行break语句时，程序就会跳转出label1标签所指定的循环。

程序运行结果如下：

(x,y) = (0,5)
(x,y) = (0,4)
(x,y) = (0,3)
(x,y) = (0,2)
(x,y) = (0,1)
(x,y) = (1,5)
(x,y) = (1,4)
(x,y) = (1,3)
(x,y) = (1,2)
Game Over!

如果break后面没有指定外循环标签，则运行结果如下：

(x,y) = (0,5)
(x,y) = (0,4)
(x,y) = (0,3)
(x,y) = (0,2)
(x,y) = (0,1)
(x,y) = (1,5)
(x,y) = (1,4)
(x,y) = (1,3)
(x,y) = (1,2)
(x,y) = (2,5)
(x,y) = (2,4)
(x,y) = (2,3)
(x,y) = (3,5)
(x,y) = (3,4)
(x,y) = (4,5)
Game Over!

比较两种运行结果，就会发现给break添加标签的意义，添加标签对于多层嵌套循环是很有必要的，适当使用可以提高程序的执行效率。

7.3.2 continue语句

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

在循环体中使用continue语句有两种方式可以带有标签，也可以不带标签。语法格式如下：

continue //不带标签
continue label //带标签，label是标签名

下面看一个示例，代码如下：

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

for (int i = 0; i < numbers.length; i++) {
    if (i == 3) {
        continue;
    }
    System.out.println("Count is: " + i);
}

在上述程序代码中，当条件i==3的时候执行continue语句，continue语句会终止本次循环，循环体中continue之后的语句将不再执行，接着进行下次循环，所以输出结果中没有3。程序运行结果如下：

Count is: 0
Count is: 1
Count is: 2
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9

带标签的continue语句示例代码如下：

label1: for (int x = 0; x < 5; x++) {　      ①
    for (int y = 5; y > 0; y--) {　      ②
        if (y == x) {
            continue label1;        ③
        }
        System.out.printf("(x,y) = (%d,%d)", x, y);
        System.out.println();
    }
}
System.out.println("Game Over!");

默认情况下，continue只会跳出最近的内循环（代码第②行for循环），如果要跳出代码第①行的外循环，可以为外循环添加一个标签label1，然后在第③行的continue语句后面指定这个标签label1，这样当条件满足执行continue语句时，程序就会跳转出外循环。

程序运行结果如下：

(x,y) = (0,5)
(x,y) = (0,4)
(x,y) = (0,3)
(x,y) = (0,2)
(x,y) = (0,1)
(x,y) = (1,5)
(x,y) = (1,4)
(x,y) = (1,3)
(x,y) = (1,2)
(x,y) = (2,5)
(x,y) = (2,4)
(x,y) = (2,3)
(x,y) = (3,5)
(x,y) = (3,4)
(x,y) = (4,5)
Game Over!

由于跳过了x == y，因此下面的内容没有输出。

(x,y) = (1,1)
(x,y) = (2,2)
(x,y) = (3,3)
(x,y) = (4,4)

本章小结

通过对本章内容的学习，读者可以了解到Java语言的控制语句，其中包括分支语句（if和switch）、循环语句（while、do-while、for和for-each）和跳转语句（break和continue）等。

配套视频

http://edu.51cto.com/topic/1507.html

配套源代码

http://www.zhijieketang.com/group/5

与本书免费版对应的还有一个收费版本：

  1. 进入百度阅读电子书
  2. 进入图灵社区电子书

原文地址：http://blog.51cto.com/tonyguan/2132405

时间： 2024-08-01 03:49:52

《Java从小白到大牛》之第7章 控制语句的相关文章

《Python从小白到大牛》第8章 控制语句

程序设计中的控制语句有三种,即顺序.分支和循环语句.Python程序通过控制语句来管理程序流,完成一定的任务.程序流是由若干个语句组成的,语句可以是一条单一的语句,也可以是复合语句.Python中的控制语句有以下几类: 分支语句:if 循环语句:while和for 跳转语句:break.continue和return 分支语句 分支语句提供了一种控制机制,使得程序具有了"判断能力",能够像人类的大脑一样分析问题.分支语句又称条件语句,条件语句使部分程序可根据某些表达式的值被有选择地执行

《Java从小白到大牛精简版》——第1章 开篇综述

Java诞生到现在已经有20多年了,但是Java仍然是非常热门的编程语言之一,很多平台中使用Java开发.表1-1所示的是TIOBE社区发布的2016年5月和2017年5月的编程语言排行榜,可见Java语言的热度,或许这也是很多人选择学习Java的主要原因. 表 1-1 TIOBE编程语言排行榜 2017年5月 2016年5月 变化 编程语言 评级 评级变化 1 1 Java 14.639% -6.320% 2 2 C 7.002% -6.220% 3 3 C++ 4.751% -1.950%

《Java从小白到大牛精简版》——前言

内容简介 本书是一本Java语言学习教程,读者群是零基础小白,通过本书的学习能够成为Java大牛.主要内容包括:Java语法基础.数据类型.运算符.控制语句.数组.字符串.面向对象基础.继承与多态.抽象类与接口.集合框架.异常处理.输入输出和网络编程等技术. 版权声明 <Java从小白到大牛精简版>免费电子图书是作者关东升原创作品,作者已将该书(包括:文字.图片和源代码)进行了版权注册,版权归作者关东升所有,仅供个人研究和学习之用.任何单位或个人不得以任何方式进行出版.篡改.编辑,任何单位或个

《Java从小白到大牛》之第10章 面向对象基础（下）

<Java从小白到大牛>纸质版已经上架了!!! 封装性与访问控制 Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的,访问控制分为4个等级:私有.默认.保护和公有,具体规则如表10-1所示. 表 101 Java类成员的访问控制 可否直接访问控制等级 同一个类 同一个包 不同包的子类 不同包非子类 私有 Yes 默认 Yes Yes 保护 Yes Yes Yes 公有 Yes Yes Yes Yes 下面详细解释一下这4种访问级别. 私有级别 {#-0} 私有级别的关键字是pri

《Java从小白到大牛》之第11章 对象

<Java从小白到大牛>纸质版已经上架了!!! 类实例化可生成对象,实例方法就是对象方法,实例变量就是对象属性.一个对象的生命周期包括三个阶段:创建.使用和销毁.前面章节已经多少用到了对象,这一章详细介绍一下对象的创建和销毁等相关知识. 创建对象 创建对象包括两个步骤:声明和实例化. 1. 声明 声明对象与声明普通变量没有区别,语法格式如下: type objectName; 其中type是引用类型,即类.接口和数组.示例代码如下: String name; 该语句声明了字符串类型对象name

《Java从小白到大牛》之第12章 继承与多态

<Java从小白到大牛>纸质版已经上架了!!! 类的继承性是面向对象语言的基本特性,多态性前提是继承性.Java支持继承性和多态性.这一章讨论Java继承性和多态性. Java中的继承 {#java} 为了了解继承性,先看这样一个场景:一位面向对象的程序员小赵,在编程过程中需要描述和处理个人信息,于是定义了类Person,如下所示: //Person.java文件 package com.a51work6; import java.util.Date; public class Person

《Java从小白到大牛》之第14章 异常处理（下）

<Java从小白到大牛>纸质版已经上架了!!! 释放资源 有时在try-catch语句中会占用一些非Java资源,如:打开文件.网络连接.打开数据库连接和使用数据结果集等,这些资源并非Java资源,不能通过JVM的垃圾收集器回收,需要程序员释放.为了确保这些资源能够被释放可以使用finally代码块或Java 7之后提供自动资源管理(Automatic Resource Management)技术. finally代码块 {#finally} try-catch语句后面还可以跟有一个final

《Python从小白到大牛》第1章 开篇综述

Python诞生到现在已经有20多年了,但是Python仍然是非常热门的编程语言之一,很多平台中使用Python开发.表1-1所示的是TIOBE社区发布的2017年3月和2018年3月的编程语言排行榜,可见Python语言的热度,或许这也是很多人选择学习Python的主要原因. Python语言历史 Python之父荷兰人吉多 范·罗苏姆(Guido vanRossum)在1989年圣诞节期间,在阿姆斯特丹,为了打发圣诞节的无聊时间,决心开发一门解释程序语言.1991年第一个Python解释器公

《Python从小白到大牛》第5章 Python编码规范

俗话说:"没有规矩不成方圆".编程工作往往都是一个团队协同进行,因而一致的编码规范非常有必要,这样写成的代码便于团队中的其他人员阅读,也便于编写者自己以后阅读. 提示关于本书的Python编码规范借鉴了Python官方的PEP8编码规范^1和谷歌Python编码规范^2. 命名规范 程序代码中到处都是标识符,因此取一个一致并且符合规范的名字非常重要.Python中命名规范采用多种不同.不同的代码元素命名不同,下面分类说明一下. 包名.全部小写字母,中间可以由点分隔开,不推荐使用下划线.