7.语句 - 简书

语句（Statement）
是程序的一条执行单元。所谓计算机程序，
本质就是一条条的语句按顺序执行的意思。本章介绍语句的概念，
并学会几种常见的逻辑控制语句。

语句的概念

表示一行可执行的代码。

public class HelloWorld
{
public static void main(String[] args)
{
int a = 10;
double b = 12.34;
a = (int) (b * b);
System.out.println("a=" + a );
}
}

其中，大括号内有 4 条语句。
它们的特点是，位置在 main 大括号里面，并且以分号结束。
并非所有以分号结束的代码都叫语句，比如 package my; 这
一行代码，由于位置不在main{ }这个大括号里，所以就不叫语句
通常把一条语句单独写在一行里，但是也可以把多条语句凑在一行里书写
写在一行的代码，就很不美观，可读性很差。

空语句

一个单独的分号也算是一条语句，称为空语句，也就是说这条语句什么也没干。

int a = 10;
;
;
;
a ++;

其中有 5 条语句，3 条是空语句。虽然只有一个分号，也算是一条语句的

复合语句

可以把多条语句合在一个大括号里，构成一个复合语句

{
int a = 10;
a ++;
}

其中，大括号内的语句合在一起可以视为一条语句，即复合语句。

if 语句

在Java里，用if语句来实现“当满足XXX条件时，执行YYY”
这样的逻辑判断
例如，在使用共享单车时需要检查使用者的年龄。如果在 12
岁以下，则禁止骑行。用 Java 代码可以表示为

int age = 11; // 年龄
if ( age < 12 )
{
System.out.println("未满 12 岁，不能骑小黄车");
}

这里就使用了 if 语句。其基本形式如下，

if ( E1 )
 {
 S1
}

其运行规则为：“当 E1 成立时，执行 S1”。也就是说，当 E1的值为 true 时执行 S1 语句

分步过程讲解

为了方便讲解，在每一行代码前面加了一个行号。
(1) 第一组测试

① int age = 11 ; // 年龄
② if ( age < 12 )
{
③ System.out.println("未满 12 岁，不能骑小黄车");
}
④ System.out.println("结束");

运行过程如下：
运行 ①：age 的值为 11
运行 ②：先计算 a<12 的值为 true ，所以会进入大括号内部
运行
运行 ③：
运行 ④：结束

(2) 第二组测试
现在，我们把初始条件 age 设为 14，再运行一下：
① int age = 14 ; // 年龄
② if ( age < 12 )
{
③ System.out.println("未满 12 岁，不能骑小黄车");
}
④ System.out.println("结束");

则运行过程如下：
运行 ①： age 的值为 14
运行 ②：先计算 a<12 的值为 false，所以直接跳出 if
运行 ④：结束

if 语句的两种基本形式

if 语句有两种基本写法，分别介绍一下。
第一种：

if ( E1 )
{
S1
}

第二种：表示“如果，。。。；否则，。。。”这样的逻辑。如果 E1
成立，就执行 S1；否则，就执行 S2。

if ( E1 ){
S1
}
else
{
S2
}

例如，一个学生的分数用 score 来表示，如果分数少于 60 分，
则判定为不及格；否则，则提示通过、并有奖励。

int score = 77; // 分数
if ( score < 60)
{
System.out.println("不及格!得重考啦！");
}
else
{
System.out.println("恭喜，通过了！");
System.out.println("有奖励！");
}
System.out.println("结束");

在 else{ } 里，添加了 2 行语句，它们会依次执行

if 语句的完全形式

用if... else if ... else if ... else可以表示“如果... 再如果 ... 再
如果...否则”这样的多重判断的逻辑。

if ( E1 )
{
S1
}
else if ( E2 )
{
S2
}
else if (E3)
{
S3
} 
else
{
SS
}

在运行时，先判断 E1 是否成立；若 E1 不成立，再判断 E2 是否成立；依次判断，一直到最后一个条件

下面举一个例子来说明这种多重条件的判断。例如，一个学生分数 score，若在 90 分以上记为 A，若在 80-90 分记为 B，若在 70-80 记为 C，若在 70 分以下记为 D。

int score = 77; 
if ( score >= 90 ) // 90 以上
{
System.out.println("等级: A");
}
else if (score >= 80) // 80-90
{
System.out.println("等级: B");
}
else if (score >= 70) // 70-80
{
System.out.println("等级: C");
}
else // 70 以下
{
System.out.println("等级: D");
}
System.out.println("结束");

常见问题

在书写 if 语句的时候，末尾不要多加分号。

实际上 if(){} 是一个整体，如果在中间加个分号，就成了 if();{} 显然是不对的

if 语句相对比较简单，容易理解。但

for 语句

要求写一段代码，计算从 1 到 100 的平方之和。

int total = 0;
total += 1 * 1;
total += 2 * 2;
...写 100 行类似的语句 ...
total += 100 * 100;
System.out.println("结果为: " + total);

在 Java 语言里，使用 for 语句来实现循环逻辑。其基本形式为，

for ( E1; E2; E3 )
{
 S1
}

其中，
E1: 初始化表达式
E2: 前置表达式（循环条件判断）
E3: 后置表达式
S1: 循环体
其执行的步骤为：
① 运行初始化表达式 E1，仅执行一次
② 运行 E2（循环条件）：条件若成立，则执行循环; 否则退
出循环
③ 运行 S1（循环体）
④ 运行 E3（后置表达式）
⑤ 执行下一轮： ② ③ ④
简单的讲，一轮循环就是 E2 >> S1 >> E3 ，每轮循环之前先
判断 E2 是否成立。E2 为 true 则执行本轮循环，否则退出循环。

现在，用 for 语句来解决引例中的问题。

int total = 0;
int i;
for ( i=1 ; i<=100 ; i++ )
{
total += i * i;
}
System.out.println("结果为: " + total);

其中，E1 ： i=1 将 i 初始化为 1E2 ：每次判断 i<=100 是否成立S1 ：循环体为 total += i * iE3 ：在循环体之后执行 i ++
其中，E2 >> S1 >> E3 构造一个循环

要求计算 1 到 100 以内，能被 3 整除的数 (如
3 6 9 12 ... )

int i;
for ( i=1 ; i<=100 ; i++ )
{
if ( i % 3 == 0)
{
System.out.println("Got: " + i );
}
}

其中，在 for 的循环体里，使用了一个 if 语句来判断 i 的值是
否为 3 的倍数。若 i % 3 == 0 ，则表明 i 就是 3 的倍数。

循环变量

可以把用于循环迭代的变量直接定义在 for 的小括号里

for (int i=1; i<=100; i++) // 在小括号里定义循环变量 i
{
// 处理
}

把 int i=1 直接定义在初始化变达式里。这种专门用于
循环的变量，有时候也可以称为循环变量。

for 语句的嵌套

在前面的例子里已经看到，for 语句里是可以嵌套包含 if 语句的。因为在理论上，if( …){ …} 在整体上可以视为一条语句，即
复合语句

各种类型的语句，是可以互相嵌套的，这是很自然的现象。例
如这种形式，

if ( ... )
{
 for (...) { }
}

或者更加复杂的写法

for (...)
{
 for (...) 
 {
 for(...) {}
 }
}

把这种现象通俗地称为嵌套

看一个例子。给定整数 n，当 n 为偶数时从小大到输出，n 为
奇数时从大到小输出。

int nnn = 11;
if( nnn % 2 == 0)
{
// nnn 为偶数，从小到大输出
for (int i=1; i<= nnn;i++)
{
System.out.print( i + " ");
}
}
else
{
// nnn 为奇数，从大到小输出
for (int i= nnn; i >0; i--)
{
System.out.print( i + " ");
}
}

其中，在 if 语句里，嵌套了 for 语句。因为理论上 for 语句是
复合语句，可以视为一条语句。print() 用于输出文本，末尾不换行。
而 println () 也用于输出文本，在末尾的时候会附加一个换行。
另外，for 语句也可以按从大到小递减的方式来实现循环逻辑。
示例如下

for (int i= nnn; i >0; i--)
{
…………………… // 略
}

要求
用*号输出以下形状的图形：

根据这个规律分析，用一个嵌套的循环（2 重循环）就可以实
现这样的功能。示例代码如下

int N = 5;
for ( int i=0; i<N; i ++) // 循环变量 i
{
for(int k=0;k <=i; k++) // 循环变量 k
{
System.out.print("*");
}
System.out.print("\n"); // 输出换行
}

按照计算机编程的惯例，一般采用从 0 开始的写法。这种从 0 开始计数的写法是推荐的写法。

break 与 continue

在循环体中，break 与 continue 可以控制循环的运行。其中，
break 用于中断循环，continue 用于跳过本轮循环

break 语句

要求打印输出一批数值，当数值超过 10 时，
停止打印

for (int i=0; i<100; i++)
{
 if ( i >= 10) 
 {
 break; // 运行到 break 时循环中止
}
 System.out.println( i + " ");
}

当运行到 i 为 10 时，i>=10 成立，执行 break 语句，退出循环

continue 语句

要求打印所有从 1 到 20 的数值，但是不包括 4 的倍数

for(int i=1; i<=20;i++)
{
if(i %4 ==0) 
{
continue; // 跳过本轮，进入下一步
}
System.out.print( i + " ");
}

当 i%4==0 时，continue 被执行，跳过本轮，进入下一轮。

在使用 break 和 continue 要注意两点：

break 和 continue 必须写在循环体里；
当存在嵌套时，break 中断的是上层循环，不是上上层循环

for 语句的变形

for (E1 ; E2; E3)
{
S1
}

在这里，E1, E2, E3 都是可以置空的。
最极端的情形，三者均为空，表示一个无限循环，示例代码如下。

for ( ; ; ) // E1,E2,E3 均置空
{
System.out.println("in loop"); 
}

即使小括号的三个部分均为空，也是符合语法规则
的

讨论一下 E1,E2,E3 分别为空的三种
变形。为了方便讨论，先给出一个标准形式的写法。以下代码，打印了从 0 到 9 的十个数字

for (int i=0; i<10; i++)
{
///////// 循环体 ////////
System.out.print(i + " ");
//////////////////
}

初始化 E1 为空

小括号里的第一部分表示初始化，会在第一次循环之前运行。
因此，在形式上可以将 E1 表达式提到 for 语句之前，并没有什么影响。

int i=0;
for ( ; i<10 ; i++) // E1 为空
{
///////// 循环体 ////////
System.out.print(i + " ")
//////////////////
}

小括号里的第一部分初始化，被提到了 for 语句之前运0行，效果没有差别

循环条件 E2 为空

E2 如果为空，则默认为 true，表示每轮循环都会执行。

for ( int i=0 ; ; i++) // E2 为空
{ 
///////// 循环体 ////////
System.out.print(i + " ");
}

其中，由于 E2 为空，所以这个循环会一直运行，没有休止。
可以在循环体中加上条件判断，来控制循环的终止。

for ( int i=0 ; ; i++)
{
 if ( i>= 10) 
{
break; // 控制循环退出
}
///////// 循环体 ////////
System.out.print(i + " ");
}

后置表达式 E3 为空

后置表达式 E3 在循环体之后运行，也可以置空。

for ( int i=0 ; i<10 ; ) // E3 为空
{
///////// 循环体 ////////
System.out.print(i + " ");
 i ++; // 放在循环体的下面执行，效果相同
}

可以发现 for 语句的写法是可以灵
活多变的。对于初学者来说，应以标准形式为主。

while 语句

while 语句也可以用于表示“循环”的逻辑。其一
般形式为

while ( E1 )
 {
 S1
}
运行规则为：“当条件 E1 成立的时候，执行循环体 S1；否则
退出循环”。

要求打印 1 到 10 之间的数值，可以
用 while 语句实现。

int i = 1; 
while ( i <=10)
{
System.out.println( i);
i++;
}

按照 while 语句的规则，每轮循环之前，要检查循环条件 i<=10 是否成立。所以，此循环会执行 10 轮，然后结束退出。

while 语句的变形

while 语句也可以变形。例如，以上例子也可以写成这种形式，

int i = 1;
while ( true ) // 循环条件总是为 true
{
if(i > 10)
{
break;
}
System.out.println( i);
i++;
}

循环条件总是为 true，所以它成了一个无限循环。为了
控制循环的退出，在循环体检查当 if(i>10)时，执行 break 语句来
控制循环的退出。

还有一种 do { S1 } while ( E1 ) 的形式的循环逻辑。这种形式不太常用

所有的循环的本质原理都是相通的，写法上也是可以互相转换的。也就是说，一个循环可以用 for 实现，也必然可以用 while来实现。使用本章所介绍的 for 语句和 while 语句，便足够实现所有循环类的控制逻辑