04 Java流程控制-循环（while+for+关键字+嵌套）

115 阅读 0 评论 76 点赞

我是靠谱客的博主慈祥纸飞机，这篇文章主要介绍04 Java流程控制-循环（while+for+关键字+嵌套），现在分享给大家，希望可以做个参考。

流程控制-循环

- - 4 流程控制（循环）
  - - 概念
    - 4.1while循环
    - - 4.1.1 语法：
      - 4.1.2 详细说明：
    - 4.2 do while循环
    - - 4.1.1 语法
      - 4.2.2 详细说明
      - 4.2.2 do-while与其它两个循环的不同
    - 4.3 for循环（重要）
    - - 4.3.1 语法
      - 4.3.2 详细说明
      - 4.3.3 **for循环的6种写法**
    - 4.4 break和continue关键字（流程控制关键字）
    - - 4.4.1 break关键字
      - 4.4.2 continue关键字
    - 4.5 嵌套循环

4 流程控制（循环）

概念

Java中基础编码结构“顺序、分支和循环”，这个编码过程中顺序结构是占主导，可以通过分支结构，改变顺序结构中执行代码的操作和提供对逻辑判断条件判断操作从而可以达到让代码选择性执行某段代码的目的，分支结构也好还是顺序结构也好，我们代码只能运行一次，如果出现需要将某些代码重复性执行多次，以现在代码结构而言是无法完成，当我们遇到代码中某段程序需要重复性执行的之后，就可以使用Java中提供一种程序结构来完成这个操作，这个结构是循环结构。

例如：开发一个机器人踢足球程序，程序中会有一个问题，如果没有进入到射门范围内，此时就需要让机器人持续的带球，重复性操作就是持续带球

使用循环结构可以轻松控制某些事情（操作）重复，重复在重复性操作

Java中提供循环结构有**“while循环、do-while循环和 for循环”**

所以在编写循环的时候主要提供要素【必要条件】，就要可以在代码结构中添加循环操作，让代码执行重复性操作

循环组成部分：

初始部分：对循环变量赋初值
循环条件：判断循环变量是否超出某个界限
循环操作：要循环执行的具体逻辑
更新变量：修改循环变量的值

4.1while循环

while循环在以后开发中占比0.9%左右【书写while循环比例也就是在0.9%】,但是是一个经典的循环结构，利用这循环结构完成某些代码重复执行

4.1.1 语法：

语法：

循环变量初值；

while(循环条件){【使用循环变量与某个值组成】

执行语句【让循环重复执行的操作】；

循环变量控制【循环变量的自增或自减】

}

执行流程：

先对布尔表达式进行判断，结果为true，则执行逻辑代码。
本次执行完毕后，再次进行判断，结果仍旧为true，则再次执行逻辑代码。
直至布尔表达式的结果为false时，才会退出循环结构，执行后续代码。
复制代码while(布尔表达式){ //逻辑代码（循环操作） }
1
2
3
4
while(布尔表达式){
	//逻辑代码（循环操作）
}

4.1.2 详细说明：

循环变量赋初值，这个变量主要作用是组成循环条件，可以参与到循环体计算与打印
循环条件：使用循环变量与某个值构建一个循环的范围，这个范围也就是循环次数

因为是范围的存在，所以循环条件多使用的**“关系表达式即常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**，偶尔可见**使用逻辑运算符与关系运算符共同组成表达式作为循环范围或者使用 == 或 != 来组建这个循环范围 **

既然循环条件使用关系或逻辑运算符的表达式，所以条件得到结果值只有true 或 false
执行语句其实就是你要让循环重复什么代码，这个代码时泛指**【打印语句、逻辑计算、分支语句或者循环语句】**
循环变量控制，因为使用循环变量与某个值构建循环范围，所有需要对循环变量加以控制**【自增或自减】，以让循环条件可以达到我们需要的循环次数**

示例：使用while循环打印1~10之间所有数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class WhileDemo {
	//提供While循环的使用
	public static void main(String[] args) {
		//使用while循环打印1~10之间所有数据
		/*
		分析：
		1.重复操作事情 ---》 【打印数据】
		2.重复操作的次数 ---》【打印1到10】应该是10个数字，重复10次
		*/
		//循环变量赋初值【定义循环开始的位置】
		int i = 1;
		//只要循环条件为true值循环就会执行，只有当循环条件为false时循环才会停止
		while (i<=10){ //循环条件
		//重复操作的事情
		System.out.println(i);
		//控制循环变量【需要让i变量进行自增操作 ++】
		i++;
		}
	}
}

案例:利用while循环计算100以内（包括100），所有的奇数、偶数和3的倍数

**if 单分支 ** （每一个数都需要判断3次）

三个条件 – if-else if —？不可以，因为if-else if原则只要有一个条件判断为true，剩余条件皆不判断
就会出现少一个打印结果情况

----选择if单分支

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class Demo {
    public static void main(String[] args) {
        //利用while循环计算100以内（包括100），所有的奇数、偶数和3的倍数
        /*
        分析:
        1.重复操作的事情 ---》 需要提供判断数据是否是奇数、偶数和3的倍数
            如果需要提供所有的奇数、偶数和3的倍数都要打印出来，此时应该提供一个什么样if判断是合理？
            三个条件 ---》 if-else if ---》不可以，因为if-else if原则 只要有一个条件判断为true，剩余条件皆不判断
                就会出现少一个打印结果情况 --》 那么应该选用谁？
        2.重复的次数 --》 从1~100之间的所有数据 ---》 100次
        */
        //循环变量赋初值
        int i = 1;
        while(i<=100){ //循环条件
        //重复操作的事情
        //先提供if-else if分支判断 --》无法完成具体需求，每个数只判断一次，只输出奇偶数
        //修改为 if 单分支
            if(i %2 == 0){
                System.out.println("偶数："+i);
            }
            if(i%2 == 1){
                System.out.println("奇数："+i);
            }
            if(i%3 ==0){
                System.out.println("3的倍数："+i);

            }
            //循环变量控制
            i++;
        }
    }
}
//
奇数：1
偶数：2
奇数：3
3的倍数：3
偶数：4
奇数：5
偶数：6
3的倍数：6
奇数：7
    .....
3的倍数：96
奇数：97
偶数：98
奇数：99
3的倍数：99
偶数：100

输入一个数，求得这个数是几位数

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数数字");
        int num = sc.nextInt();
        int temp = num;
        if (num==0){
            System.out.println(temp +"是1位数");
        }else{
            //定义一个变量用于保存循环的次数
             int count = 0;
             while (num!=0) {
                 num = num / 10;
                 //每次循环次数+1
                 count++;
             }
            System.out.println(temp+"是"+count+"位数");
        }        
    }
}

4.2 do while循环

do-while循环也是循环结构中一种，do-while循环在语法上看与while循环比较相近，类似于while循环语法“倒立”来实现，do-while循环开发中占比0.1%【在开发中使用do-while这种循环结构的语法较少】

4.1.1 语法

语法：

循环变量赋初值；

do{

执行语句【重复操作的代码】;

循环变量自增或自减【循环变量控制】;

}while(循环条件);

4.2.2 详细说明

循环变量赋初值，这个变量主要作用是组成循环条件，可以参与到循环体计算与打印

因为是范围的存在，所以循环条件多使用的**“关系表达式即常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**，偶尔可见使用逻辑运算符与关系运算符共同组成表达式作为循环范围或者使用 == 或 != 来组建这个循环范围

既然循环条件使用关系或逻辑运算符的表达式，所以条件得到结果值只有true 或 false

循环条件：使用循环变量与某个值构建一个循环的范围，这个范围也就是循环次数
执行语句：其实就是你要让循环重复什么代码，这个代码时泛指**【打印语句、逻辑计算、分支语句或者循环语句】**
循环变量控制：因为使用循环变量与某个值构建循环范围，所有需要对循环变量加以控制**【自增或自检】，以让循环条件可以达到我们需要的循环次数**

常见的自增或自检操作使用**“++ 或 – 运算符”，偶尔可见使用运算符“+=、-=、*= 、= 运算符“**

PS：在书写do-while循环的时候一定要注意循环末尾的【;】一要添加

案例：使用do-while循环打印1~10之间所有数据

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo {
    public static void main(String[] args) {
        //使用do-while循环打印1~10之间所有数据
        //1.提供循环变量赋初值
        int i = 1;
        do{
            //重复操作的事情
            System.out.println(i);
            //控制循环变量
            i++;
        }while (i<=10);
        //只要循环条件true就执行循环，只有当循环条件为false停止循环
    }
}

案例：学生根据老师的评语，是否继续敲代码，直到测评为ok，就结束

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String result;
        do{
            System.out.println("敲代码ing...你看我的代码怎么样？？？");
            System.out.println("评价：");
            result = sc.next();
        }while (!result.equals("ok"));
    }
}

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        String result = sc.next();
        do{
            System.out.println("敲代码ing...你看我的代码怎么样？？？");
            System.out.println("评价：");
        }while (!result.equals("ok"));
    }
}

4.2.2 do-while与其它两个循环的不同

do-while循环特点就是先执行操作，然后在执行判断，

while循环和for循环都是需要先执行判断，然后再执行操作，

所以就算在判断条件不成立的前提下，do-while循环依旧会执行一次，

而while和for循环是不会执行的

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Demo {
    public static void main(String[] args) {
        //在同等条件下使用while循环和do-while进行数据打印操作
        //将正常案例操作注释，提供特条件，无论是while还是do-while都设置条件为 <= 0
        System.out.println("----------while-----------");
//        int i =1;
//        while (i<=5){
//            System.out.println(i);
//            i++;
//        }
          int i=1;
          while (i<=0){
              System.out.println(i);
              i++;
          }
          //false,直接退出循环，输出空


        System.out.println("----------do while-----------");
//        int j =1;
//        do{
//            System.out.println(j);
//            j++;
//        }while (j<=5);
            int j =1;
            do{
                System.out.println(j);
            j++;
            }while (j<=0);
            //先输出j=1，再判断，输出1
    }
}

4.3 for循环（重要）

for循环也是循环结构中一种，而且这个循环在开发中占比极高（99%），因为for循环将所有循环使用条件进行归纳，所以循环语句看起来就更加简洁，所以开发者就更加偏向于使用for循环

4.3.1 语法

语法：

for(循环变量赋初值；循环条件；循环变量自增或自减){

重复执行操作【执行语句】；

}

4.3.2 详细说明

循环变量赋初值，这个变量主要作用是组成循环条件，可以参与到循环体计算与打印
循环条件：使用循环变量与某个值构建一个循环的范围，这个范围也就是循环次数

因为是范围的存在，所以循环条件多使用的**“关系表达式即常用关系运算符 > 、>= 、< 、<=” 来组成循环范围**，偶尔可见使用逻辑运算符与关系运算符共同组成表达式作为循环范围或者使用 == 或 != 来组建这个循环范围

既然循环条件使用关系或逻辑运算符的表达式，所以条件得到结果值只有true 或 false
执行语句其实就是你要让循环重复什么代码，这个代码时泛指**【打印语句、逻辑计算、分支语句或者循环语句】**
循环变量控制，因为使用循环变量与某个值构建循环范围，所有需要对循环变量加以控制【自增或自检】，以让循环条件可以达到我们需要的循环次数

常见的自增或自检操作使用**“++ 或 – 运算符”，偶尔可见使用运算符“+=、-=、*= 、= 运算符“**

PS: for循环在书写过程中需要在小括号内使用【;】分隔不同的循环条件

for循环中将循环变量赋初值定义在小括号内，而不像while和do-while将循环变量赋初值定义在循环外部，所以for循环中循环变量只能在循环体内中使用【在没有使用变形语法之前】

案例：使用for循环完成1-10之间打印【不包括10】

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo {
    public static void main(String[] args) {
        //使用for循环完成1-10之间打印【不包括10】
        //循环变量赋初值;循环条件;循环变量控制
        for (int i = 1; i <10 ; i++) {
            System.out.println(i);
        }
        //因为将循环变量付出值定义在循环体的内部，所以无法在for外部使用到这个循环变量
        //Cannot resolve symbol 'i' IDEA会提示你 找不到i这个变量
        //System.out.println(i);
    }
}

案例：使用for循环完成 1~100之间所有数据之和【包括100】

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
public class Demo {
    public static void main(String[] args) {
        //使用for循环完成 1~100之间所有数据之和【包括100】
        //提供一个存储累加结果的变量
        int sum = 0;
        for (int i = 1; i <100 ; i++) {
            sum = sum +i;
        }
        System.out.println(sum);
    }
}

4.3.3 for循环的6种写法

因for循环在开中使用的频率是比较高，为了满足for循环对于不同场景的应用，可以将for循环进行6中变形，以适用于不通过操作场景.

复制代码

package JavaseDemo;

/**
 * description: never-bug
 */
public class Demo {
    //for循环6种写法
    public static void main(String[] args) {
        //1.标准方式
        for(int i = 0 ; i<10;i++){
            System.out.println(i);
        }
        System.out.println("----------------------------------------------");
        //2.因为for循环是将循环变量定义在循环小括号中，所以外界无法使用，如果要外界可以使用i变量
        //将for循环循环变量赋初值的定义提高到for循环的外部，这样for外部就可以使用到循环变量
        //2.1 不在小括号中省略不定义，而是在循环外部定义与赋值
        int i = 0;
        for (;i<10;i++){
            System.out.println(i);
        }
        //2.2 不在小括号中省略不定义，但是在小括号中进行赋值，在for循环外部进行定义
        int j;
        for (j = 0; j<10;j++){
            System.out.println(j);
        }
        //3.循环变量的控制不在小括号内声明【在小括号内省略】，在大括号内提供
        for(int m = 0 ; m <10;){
            System.out.println(m);
            m++;
        }
        //4.for循环变量while循环，将循环变量赋初值和循环变量的控制分别定义在循环的外部和内部，在小括号中省略
        int n = 0;
        for (;n<10;){
            System.out.println(n);
            n++;
        }
        //5.for循环的死循环写法1 【不提供循环条件，默认认为条件为true】
        /*
        什么是死循环？ --循环会一直执行，循环条件始终为true，这样循环称之为死循环
        在某些书写循环的操作中，无法明确得知循环次数，此时就可以使用死循环完成循环操作，还要配合关键字break停止循环

Java中提供三个循环都可以书写死循环
        while对应死循环版本
        while(true){ // 让循环条件始终为true
        }
        do-while对应死循环版本
        do{
        }while(true);// 让循环条件始终为true
        */
        //***for循环不提供循环条件，默认认为条件为true***
        for(int p = 0;;p++){
            System.out.println(p);
        }
        //6.for循环的死循环写法2  【完全省略】，在for循环小括号什么都不定义
        /*
         for(;;){
        System.out.println("我是死循环");
        }
        */
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package JavaseDemo;

/**
 * description: never-bug
 */
public class Demo {
    //for循环6种写法
    public static void main(String[] args) {
        //1.标准方式
        for(int i = 0 ; i<10;i++){
            System.out.println(i);
        }
        System.out.println("----------------------------------------------");
        //2.因为for循环是将循环变量定义在循环小括号中，所以外界无法使用，如果要外界可以使用i变量
        //将for循环循环变量赋初值的定义提高到for循环的外部，这样for外部就可以使用到循环变量
        //2.1 不在小括号中省略不定义，而是在循环外部定义与赋值
        int i = 0;
        for (;i<10;i++){
            System.out.println(i);
        }
        //2.2 不在小括号中省略不定义，但是在小括号中进行赋值，在for循环外部进行定义
        int j;
        for (j = 0; j<10;j++){
            System.out.println(j);
        }
        //3.循环变量的控制不在小括号内声明【在小括号内省略】，在大括号内提供
        for(int m = 0 ; m <10;){
            System.out.println(m);
            m++;
        }
        //4.for循环变量while循环，将循环变量赋初值和循环变量的控制分别定义在循环的外部和内部，在小括号中省略
        int n = 0;
        for (;n<10;){
            System.out.println(n);
            n++;
        }
        //5.for循环的死循环写法1 【不提供循环条件，默认认为条件为true】
        /*
        什么是死循环？ --循环会一直执行，循环条件始终为true，这样循环称之为死循环
        在某些书写循环的操作中，无法明确得知循环次数，此时就可以使用死循环完成循环操作，还要配合关键字break停止循环

        Java中提供三个循环都可以书写死循环
        while对应死循环版本
        while(true){ // 让循环条件始终为true
        }
        do-while对应死循环版本
        do{
        }while(true);// 让循环条件始终为true
        */
        //***for循环不提供循环条件，默认认为条件为true***
        for(int p = 0;;p++){
            System.out.println(p);
        }
        //6.for循环的死循环写法2  【完全省略】，在for循环小括号什么都不定义
        /*
         for(;;){
        System.out.println("我是死循环");
        }
        */
    }
}

总结 for循环的6种写法

//for循环的6种写法

//2.因为for循环是将循环变量定义在循环小括号中，所以外界无法使用，如果要外界可以使用i

变量

//将for循环循环变量赋初值的定义提高到for循环的外部，这样for外部就可以使用到循环变量

//2.1 不在小括号中省略不定义，而是在循环外部定义与赋值

i

//2.2 不在小括号中省略不定义，但是在小括号中进行赋值，在for循环外部进行定义

//3.循环变量的控制不在小括号内声明【在小括号内省略】，在大括号内提供for(int m = 0 ; m <10;){

System.out.println(m); m++;

}

//4.for循环变量while循环，将循环变量赋初值和循环变量的控制分别定义在循环的外部和内部，在小括号中省略

int n = 0; for (;n<10;){

System.out.println(n); n++;

}

//5.for循环的死循环写法

/*

什么是死循环？ --》循环会一直执行，循环条件始终为true，这样循环称之为死循环

在某些书写循环的操作中，无法明确得知循环次数，此时就可以使用死循环完成循环操作，还要配合关键字break停止循环

Java中提供三个循环都可以书写死循环while对应死循环版本

while(true){ // 让循环条件始终为true

}

4.4 break和continue关键字（流程控制关键字）

除了通过循环条件可以控制循环之外，还可以通过break和continue关键字进行循环的控制操作

4.4.1 break关键字

break关键字的作用：停止【终止】当前循环，使用break关键字之后，无需等待循环条件为false

在停止循环，只需在循环体中使用break关键字就可以停止循环执行

PS：当前循环是break使用在什么位置，这个循环就是当前循环

使用这个关键字的时机是，不需要等待循环条件为false时停止循环，就可以使用break关键字

案例：计算16~100之间能被15整除的最小值

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Demo {
    //计算16~100之间能被15整除的最小值
    public static void main(String[] args) {
        //break操作案例:计算16~100之间能被15整除的最小值
        for(int i = 16 ; i<100; i++){
            if(i%15 == 0){//将15整除了
                System.out.println(i);
            //当获得最小值30的时候就不需要让循环继续执行了，停止循环而不是等到循环条件为false停止
                break;
                // 当System.out.print(" "+i); 且无break;输出 30 45 60 75 90
            }
        }
    }
}

4.4.2 continue关键字

continue关键字和break关键字有本质上区别，continue关键字并不会完全终止循环，而是跳过（终止）本次循环，开启下一次循环，就算在循环中使用了continue关键字，循环停止也是根据循环条件为false时才会停止

使用这个关键字的使用时机，需要在循环执行过程中，某些次数循环不执行，而不是整体停止循环，那么就可以continue关键字

案例：模拟电梯上行过程（1-24层），除了第4层不停止之外，剩余都停止（除了4不打印之外，剩余都
打印）

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
public class Demo {
    public static void main(String[] args) {
        //continue操作案例：模拟电梯上行过程（1-24层），除了第4层不停止之外，剩余都停止（除了4不打印之外，剩余都打印）
        for(int i = 1 ; i<=24;i++){
            if (i == 4){
                continue;  //跳过4
            }
            System.out.println(i);
        }
    }
}

4.5 嵌套循环

循环的嵌套就和分支语句嵌套是一样，允许在循环的内部执行语句中在书写一个循环，在整个循环结构中所有循环语句都可以互相嵌套，但是for循环在开发中占比最高，所以以for循环为例，循环嵌套

循环嵌套的理解其实就是在原有执行语句的位置【即重复操作的代码】，书写不是“打印、计算或分支语句”，而是提供了一个新的循环，这样形式就是循环嵌套

循环嵌套中有一个经典的理论：外层循环执行一次，内层循环执行多次

某些操作中提供一层循环是无法满足所有循环逻辑，所以在这样前提下，我们就需要提供嵌套循环了

需求：打印下面样式

1 2 3 4 5

2 4 6 8 10

3 6 9 12 15

4 8 12 16 20

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class A{
    public static void main(String[] args) {
        /*
        1 2 3 4 5
        2 4 6 8 10
        3 6 9 12 15
        4 8 12 16 20
        */
        //外层循环中 变量是可以参与到 内层循环计算中
        // 参与到 内层循环中 j的赋值、 j的循环条件和参与到内层循环的重复执行操作中
        for(int i = 1 ; i<=4;i++) {
            for (int j = 1; j <= 5; j++) {
        /*
        可以在打印语句中添加 “t” 代表4个空格 也是键盘上tab键
         */
                System.out.print(j*i + "tt");
            }
            //调用一个带有ln方法进行打印，添加换行操作
            System.out.println();
        }
    }
}

可以将当前代码中这种循环形式理解为在看书，外层第一层循环【i层】相当于是书中页数，内层

（第二层）循环【j层】相当于书页作用内一行内容，只有当书中每一行内容都看完之后，才可以翻页即只有内层循环执行完毕之后，外层循环才会开启下一次

执行流程：当前代码执行到嵌套循环时，首先先执行外层循环的循环变量赋初值【执行1次】，判断外层循环循环条件是否成立，如果成立就执行大括号中的，内层循环，先执行循环变量赋初值

【随外层循环的次数而进行初始化】，然后判断内层循环的循环条件，如果为true，就执行内层循环中大括号内执行语句，然后内层循环变量自增或自减，再次执行内层循环条件判断，直到循环条件为false，内层循环停止，此时外层循环开始循环变量自增或自减，然后再判断外层循环条件，如果为true，就会再次开启内层循环，否则循环完全结束

PS:外层循环变量是可以参与到内层循环操作的，可以影响内层循环条件，参与到内存循环计算

最后

以上就是慈祥纸飞机最近收集整理的关于04 Java流程控制-循环（while+for+关键字+嵌套）的全部内容，更多相关04内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：# Java基础
浏览次数：115 次浏览
发布日期：2023-05-16 21:16:01
本文链接：https://www.kaopuke.com/article/k-p-k_14_ujo_2_f4_14__7__2_y.html

04 Java流程控制-循环（while+for+关键字+嵌套）

流程控制-循环

4 流程控制（循环）

概念

4.1while循环

4.1.1 语法：

4.1.2 详细说明：

4.2 do while循环

4.1.1 语法

4.2.2 详细说明

4.2.2 do-while与其它两个循环的不同

4.3 for循环（重要）

4.3.1 语法

4.3.2 详细说明

4.3.3 for循环的6种写法

4.4 break和continue关键字（流程控制关键字）

4.4.1 break关键字

4.4.2 continue关键字

4.5 嵌套循环

最后

评论列表共有 0 条评论

发表评论取消回复

04 Java流程控制-循环（while+for+关键字+嵌套）

流程控制-循环

4 流程控制（循环）

概念

4.1while循环

4.1.1 语法：

4.1.2 详细说明：

4.2 do while循环

4.1.1 语法

4.2.2 详细说明

4.2.2 do-while与其它两个循环的不同

4.3 for循环（重要）

4.3.1 语法

4.3.2 详细说明

4.3.3 for循环的6种写法

4.4 break和continue关键字（流程控制关键字）

4.4.1 break关键字

4.4.2 continue关键字

4.5 嵌套循环

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复