02_Java基本语法_5

 

2.2.11.4 for 循环

当很明确地知道循环要执行的次数时，就可以使用for循环，其语句格式如下：

for (初始化表达式; 判断表达式; 修正表达式)

{

语句1;

…

语句n;

}

若是在循环主体中要处理的语句只有1个，可以将大括号去除。下面列出了for循环的流程。

1、第一次进入for循环时，为循环控制变量赋起始值。

2、根据判断条件的内容检查是否要继续执行循环，当判断条件值为真（true）时，继续执行循环主体内的语句；判断条件值为假（false）时，则会跳出循环，执行其他语句。

3、执行完循环主体内的语句后，循环控制变量会根据增减量的要求，更改循环控制变量的值，再回到步骤2重新判断是否继续执行循环。

根据上述描述，可以绘制出如图2-16所示的for循环流程图。

 

图2-16  for 循环的基本流程

范例TestJava2_29可以让大家熟悉for循环的使用，它是利用for循环来完成由1至100的数的累加运算。

范例：TestJava2_29.java 

// 以下程序说明了for循环的使用方法

public class TestJava2_29
{
    public static void main(String[] args)
    {

        int iSum = 0;

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

        System.out.println("1+2+3+...+100=" + iSum);

    }
}

 

输出结果：

1+2+3+...+100=5050

2.2.11.5 while 循环

while是循环语句，也是条件判断语句。当事先不知道循环该执行多少次的时，就要用到while循环。

while循环的格式如下：

while (判断条件) 

{ 

语句1;

语句2;

…

语句n;

} 

当while循环主体有且只有一个语句时，可以将大括号除去。在while循环语句中，只有一个判断条件，它可以是任何表达式，当判断条件的值为真，循环就会执行一次，再重复测试判断条件、执行循环主体，直到判断条件的值为假，才会跳离while循环。

下面列出了while循环执行的流程。

1、第一次进入while循环前，就必须先为循环控制变量（或表达式）赋起始值。

2、根据判断条件的内容决定是否要继续执行循环，如果条件判断值为真（True），继续执行循环主体；条件判断值为假（False），则跳出循环执行其他语句。

3、执行完循环主体内的语句后，重新为循环控制变量（或表达式）赋值（增加或减少），由于while循环不会自动更改循环控制变量（或表达式）的内容，所以在while循环中为循环控制变量赋值的工作要由设计者自己来做，完成后再回到步骤2重新判断是否继续执行循环。

根据上述的程序流程，可以绘制出如图2-17所示的while循环流程图：

 

图2-17  while循环的基本流程

范例：TestJava2_30.java 

// 以下程序说明了while循环的使用方法

public class TestJava2_30
{
    public static void main(String[] args)
    {

        int i = 1, iSum = 0;

        while (i <= 100)
        {

            iSum += i;

            i++;

        }

        System.out.println("1+2+3+...+100=" + iSum);
    }
}

 

输出结果：

1+2+3+...+100=5050

程序说明：

1、在第6行中，将循环控制变量i的值赋值为1。

2、第7行进入while循环的判断条件为i<=100，第一次进入循环时，由于i的值为1，所以判断条件的值为真，即进入循环主体。

3、第8~11行为循环主体，sum+i后再指定给sum存放，i的值加1，再回到循环起始处，继续判断i的值是否仍在所限定的范围内，直到i大于100即跳出循环，表示累加的操作已经完成，最后再将sum的值输出即可。

当明确知道要循环的次数的时候，就使用for循环。

当不确定循环次数，只知道循环结束条件时，可以使用while循环。

2.2.11.6 do…while 循环

do…while循环也是用于未知循环执行次数的时候，而while循环及do…while循环最大不同就是进入while循环前，while语句会先测试判断条件的真假，再决定是否执行循环主体，而do…while循环则是“先做再说”，每次都是先执行一次循环主体，然后再测试判断条件的真假，所以无论循环成立的条件是什么，使用do…while循环时，至少都会执行一次循环主体。

do…while循环的格式如下：

do

{

语句1;

语句2;

…

语句n;

}while(判断条件);

当循环主体只有一个语句时，可以将左、右大括号去除。第一次进入do...while循环语句时，不管判断条件（它可以是任何表达式）是否符合执行循环的条件，都会直接执行循环主体。循环主体执行完毕，才开始测试判断条件的值，如果判断条件的值为真，则再次执行循环主体，如此重复测试判断条件、执行循环主体，直到判断条件的值为假，才会跳离do…while循环。下面列出了do…while循环执行的流程：

1．进入do...whle循环前，要先为循环控制变量（或表达式）赋起始值。

2．直接执行循环主体，循环主体执行完毕，才开始根据判断条件的内容决定是否继续执行循环；条件判断值为真（true）时，继续执行循环主体；条件判断值为假（false）时，则跳出循环，执行其他语句。

3．执行完循环主体内的语句后，重新为循环控制变量（或表达式）赋值（增加或减少），由于do…while循环和while循环一样，不会自动更改循环控制变量（或表达式）的内容，所以在do…while循环中赋值循环控制变量的工作要由自己来做，再回到步骤2重新判断是否继续执行循环。

根据上述的描述，可以绘制出如图2-18所示的do..while循环流程图：

 

图2-18  do…whle循环的基本流程

范例：TestJava2_31.java 

// 以下程序说明了do...while循环的使用

public class TestJava2_31
{
    public static void main(String[] args)
    {

        int i = 1, iSum = 0;

        do
        {

            iSum += i;

            i++;

        } while (i <= 100);

        System.out.println("1+2+3+...+100=" + iSum);
    }

}

 

输出结果：

1+2+3+...+100=5050

程序说明：

首先声明程序中要使用的变量i（循环记数及累加操作数）及sum（累加的总和），并将sum设初值为0；由于要计算1+2+…+100，因此在第一次进入循环的时候，将i的值设为1，接着判断i是否小于等于100，如果i小于等于100，则计算sum+i的值后再指定给sum存放。i的值已经不满足循环条件时，i即会跳出循环，表示累加的操作已经完成，再输出sum的值，程序即结束运行。

while语句是先判断后执行，也就是说如果条件不满足，则肯定不会执行。 

do…while语句是先执行一次之后再判断，如果条件不满足则退出循环，此语句循环体至少执行一次。

在日常生活中，如果能够多加注意，并不难找到do…while循环的影子！举例来说，在利用提款机提款前，会先进入输入密码的画面，让使用者输入三次密码，如果皆输入错误，即会将银行卡吞掉，其程序的流程就是利用do…while循环设计而成的。

2.2.11.7 循环嵌套

当循环语句中又出现循环语句时，就称为嵌套循环。如嵌套for循环、嵌套while循环等，当然也可以使用混合嵌套循环，也就是循环中又有其他不同种类的循环。

以打印九九乘法表为例，练习嵌套循环的用法。

范例：TestJava2_32.java 

 

// 以下程序说明了for循环的嵌套使用方法

public class TestJava2_32
{
    public static void main(String[] args)
    {
        // 用两层for循环输出乘法表

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

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

                System.out.print(j + "*" + i + "=" + (i * j) + "\t");
            }
            
            System.out.print("\n");
        }
    }
}

 

 

 

输出结果：

1*1=1

1*2=22*2=4

1*3=32*3=63*3=9

1*4=42*4=83*4=124*4=16

1*5=52*5=103*5=154*5=205*5=25

1*6=62*6=123*6=184*6=245*6=306*6=36

1*7=72*7=143*7=214*7=285*7=356*7=427*7=49

1*8=82*8=163*8=244*8=325*8=406*8=487*8=568*8=64

1*9=92*9=183*9=274*9=365*9=456*9=547*9=638*9=729*9=81

程序说明：

1、i为外层循环的循环控制变量，j为内层循环的循环控制变量。

2、当i 为1时，符合外层for循环的判断条件（i<=9），进入另一个内层for循环主体，由于是第一次进入内层循环，所以j的初值为1，符合内层for循环的判断条件（j<=i），进入循环主体，输出i*j的值（1*1=1），j再加1等于2，不符合内层for循环的判断条件（j<=i），即内层的做完，回到外层循环，然后i++，此时，i 会加1成为2，符合外层for循环的判断条件，继续执行内层for循环主体，直到i的值大于9时即离开嵌套循环。

3、整个程序到底执行了几次循环呢？可以看到，当i 为1时，内层循环会执行1次（j为1）,当i为2时，内层循环也会执行2次（j为1~2），以此类推的结果，这个程序会执行45次循环，而显示器上也正好输出45个式子。

请考虑利用一层循环实现99乘法表。

2.2.11.8 循环的跳离

在Java语言中，有一些跳离的语句，如break、continue等语句。

2.2.11.8.1 break 语句

break语句可以强迫程序跳离循环，当程序执行到break语句时，即会离开循环，继续执行循环外的下一个语句，如果break语句出现在嵌套循环中的内层循环，则break 语句只会跳离当前层的循环。以下图的for循环为例，在循环主体中有break语句时，当程序执行到break，即会离开循环主体，而继续执行循环外层的语句。

 

以下面的程序为例，利用for循环输出循环变量i的值，当i除以3所取的余数为0时，即使用break语句的跳离循环，并于程序结束前输出循环变量i的最终值。

范例：TestJava2_33.java 

// 下面的程序是介绍break的使用方法

public class TestJava2_33
{
    public static void main(String[] args)
    {
        int i = 0;

        for (i = 1; i <= 10; i++)
        {

            if (i % 3 == 0)
            {
                break;    // 跳出整个循环体
            }

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

        }

        System.out.println("循环中断：i = " + i);

    }
}

 

输出结果：

i = 1

i = 2

循环中断：i = 3

程序说明：

1、第7~12行为循环主体，i为循环的控制变量。

2、当i%3为0时，符合if的条件判断，即执行第10行的break语句，跳离整个for循环。此例中，当i的值为3时，3%3的余数为0，符合if的条件判断，离开for循环，执行第13行：输出循环结束时循环控制变量i的值3。

通常设计者都会设定一个条件，当条件成立时，不再继续执行循环主体。所以在循环中出现break语句时，if 语句通常也会同时出现。此外，可以回想一下前面提到过的switch语句中也有一个break。

与C++不同的是，Java还提供了一种带标签的break语句，用于跳出多重嵌套循环语句。通常标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号。例如：

        loop:

        for (int i = 0; i < 10; i++)
        {

            for (int j = 0; j < 10; j++)
            {

                System.out.println(j);

                if (j == 5)

                {
                    break loop;
                }

            }

        }

        System.out.println("跳出for嵌套循环~");

 

2.2.11.8.2 continue 语句

continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，即会停止运行剩余的循环主体，而是回到循环的开始处继续运行（即跳过一次执行，继续进行循环的下次操作）。以下图的for 循环为例，在循环主体中有continue语句，当程序执行到continue，即会回到循环的起点，继续执行循环主体的部分语句。

 

将程序TestJava2_33 中的break 语句改成continue 语句就形成了程序TestJava2_34.java。可以观察一下这两种跳离语句的不同。break语句是跳离当前层循环，而continue语句是回到循环的起点。程序如下所示：

范例：TestJava2_34.java

// 下面的程序是介绍continue的使用方法

public class TestJava2_34
{
    public static void main(String[] args)
    {
        int i;

        for (i = 1; i <= 10; i++)
        {

            if (i % 3 == 0)
            {
                continue;    // 跳出一次循环
            }

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

        System.out.println("循环中断：i = " + i);
    }
}

 

输出结果：

i = 1

i = 2

i = 4

i = 5

i = 7

i = 8

i = 10

循环中断：i = 11

程序说明：

1、第7~12行为循环主体，i为循环控制变量。

2、当i%3为0时，符合if的条件判断，即执行第10行的continue语句，跳离目前的for循环（不再执行循环体内的其他的语句），而是回到循环开始处继续判断是否执行循环。此例中，当i 的值为3、6、9时，取余数为0，符合if 判断条件，离开当前层的for循环，再回到循环开始处继续判断是否执行循环。

3、当i 的值为11时，不符合循环执行的条件，此时执行程序第13行：输出循环结束时循环控制变量i的值11。

当判断条件成立时，break语句与continue语句会有不同的执行方式。break语句不管情况如何，先离开循环再说；而continue语句则不再执行此次循环的剩余语句，直接回到循环的起始处。

·本章摘要：

1、Java语言的注释方式有三种：

（1）、单行注释：“//”记号开始，至该行结束；

（2）、多行注释：“/*”与“*/”这两个符号之间的文字；

（3）、文档注释：“/**”与“*/”这两个符号之间的文字；

2、如果将一个类声明成public，则它的文件名称必须取成这个类的名称才能顺利编译。

3、main()在Java里是一个相当特殊的method，它一定要声明成public，且main() method没有返回值，所以在它之前要加上void关键字。

4、System.out是指标准输出，其后所连接的println是由print与line所组成的，意思是将后面括号中的内容打印在标准输出设备——显示器上，然后换行。

5、由于Java程序是由类所组成，所以在完整的Java程序里，至少要有一个类。

6、Java的变量名称可以由英文字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，也不能是Java中的保留关键字。此外，Java的变量有大小写之分。

7、变量的设置有以下两种方法：在声明的时候设置（初始化）、声明后再设置。

8、Java的数据类型可分为下列两种：基本数据类型和引用数据类型。

9、Java提供long、int、short及byte四种整数类型的最大值、最小值的代码。最大值的代码是MAX_VALUE，最小值是MIN_VALUE。如果使用某个类型的最大值或最小值，只要在这些代码之前，加上它们所属的类的全名即可。

10、Unicode，它为每个字符制订了一个唯一的数值，如此在任何的语言、平台、程序都可以安心地使用。

11、布尔（boolean）类型的变量，只有true（真）和false（假）两个值。

12、数据类型的转换可分为下列两种：“自动类型转换”与“强制类型转换”。

13、表达式是由操作数与运算符所组成的。

14、一元运算符只需要一个操作数。如“+3”、“~a”、“-a”与“!a”等均是由一元运算符与一个操作数所组成的。

15、算术运算符的成员有：加法运算符、减法运算符、乘法运算符、除法运算符、余数运算符以及正负号。

16、if语句可依据判断的结果来决定程序的流程。

17、递增与递减运算符有着相当大的便利性，善用它们可提高程序的简洁程度。

18、括号（）是用来处理表达式的优先级的，也是Java的运算符。

19、当表达式中有类型不匹配时，有下列的处理方法：

（1）占用较少字节的数据类型会转换成占用较多字节的数据类型。

（2）有short和int类型，则用int类型。

（3）字符类型会转换成short类型。

（4）int类型转换成float类型。

（5）若一个操作数的类型为double，则其它的操作数也会转换成double类型。

（6）布尔类型不能转换至其他的类型。

20、程序的结构包含：

（1）顺序结构

（2）选择结构

（3）循环结构

21、需要重复执行某项功能时，循环就是最好的选择。可以根据程序的需求与习惯，选择使用Java所提供的for、while及do…while循环来完成。

22、break语句可以让强制程序逃离循环。当程序运行到break语句时，即会离开循环，继续执行循环外的下一个语句，如果break语句出现在嵌套循环中的内层循环，则break语句只会逃离当前层循环。

23、continue语句可以强制程序跳到循环的起始处，当程序运行到continue语句时，即会停止运行剩余的循环主体，而到循环的开始处继续运行。

24、选择结构包括了if、if-else及switch语句，语句中加上了选择的结构之后，就像是十字路口，根据不同的选择，程序的运行会有不同的方向与结果。

25、在循环里也可以声明变量，但所声明的变量只是局部变量，只要跳出循环，这个变量便不能再使用。

 

 

感谢阅读。如果感觉此章对您有帮助，却又不想白瞟