流程控制-循环结构

Bertha 。 2023-09-30 13:28 18阅读 0赞

【1】语法结构：  
while (布尔表达式) \{  
循环体;  
\}  
在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会再开始前重新计算一次。  
语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。  
while循环结构流程图如图所示:

![0b703a6e3d430e5d8a0957c8cf37a064.png][]

【2】练习：1+2+3+4+5

public class TestWhile{
            public static void main(String[] args){
                    //功能：1+2+3+4+5
                    //1.定义变量：
                    int num1 = 1;
                    int num2 = 2;
                    int num3 = 3;
                    int num4 = 4;
                    int num5 = 5;
                    //2.定义一个求和变量，用来接收和：
                    int sum = 0;
                    sum += num1;
                    sum += num2;
                    sum += num3;
                    sum += num4;
                    sum += num5;
                    
                    //3.输出和
                    System.out.println(sum);
            }
    }

上述代码缺点：变量的定义个数太多了  
解决：

public class TestWhile{
            public static void main(String[] args){
                    //功能：1+2+3+4+5
                    //1.定义变量：
                    int num = 1;
                    //2.定义一个求和变量，用来接收和：
                    int sum = 0;
                    sum += num;
                    num++;
                    sum += num;
                    num++;
                    sum += num;
                    num++;
                    sum += num;
                    num++;
                    sum += num;
                    num++;
                    
                    //3.输出和
                    System.out.println(sum);
            }
    }

上述代码缺点：重复写的代码太多了  
解决：---》引入java中循环结构：

public class Test009 {
        public static void main(String[] args){
            //功能：1+2+3+4+5
            //1.定义变量：
            int num = 1;//[1]条件初始化
            //2.定义一个求和变量，用来接收和：
            int sum = 0;
            while(num<=5){//[2]条件判断
                sum += num;//[3]循环体
                num++;//[4]迭代
            }
            //3.输出和
            System.out.println(sum);
        }
    }

总结：  
【1】循环作用：将部分代码重复执行。  
循环只是提高了程序员编写代码的效率，但是底层执行的时候依然是重复执行。  
【2】循环四要素：

![708a529dcc980351d1253777540cf00f.png][]

初始化谁，就判断谁，判断谁，就迭代谁  
执行过程：\[1\]\[2\]\[3\]\[4\] \[2\]\[3\]\[4\] \[2\]\[3\]\[4\]。。。。

【3】循环的执行过程：

![f72f5133e3b770abea43fdc2a8c9389c.png][]

【4】验证循环的执行过程：

![bc184d2a445795f208152c67e6668157.png][]

练习

【1】1+2+3+4+5+。。。。+100  
【2】2+4+6+8+。。。。+998+1000  
【3】5+10+15+20+。。。+100  
【4】99+97+95+。。5+3+1  
【5】1\*3\*5\*7\*9\*11\*13

public class TestWhile02{
            public static void main(String[] args){
                    /*
                    【1】1+2+3+4+5+。。。。+100
                    int i = 1;
                    int sum = 0;
                    while(i<=100){
                            sum += i;
                            i++;
                    }
                    System.out.println(sum);
                    【2】2+4+6+8+。。。。+998+1000
                    int i = 2;
                    int sum = 0;
                    while(i<=1000){
                            sum += i;
                            i = i+2;
                    }
                    System.out.println(sum);
                    【3】5+10+15+20+。。。+100
                    int i = 5;
                    int sum = 0;
                    while(i<=100){
                            sum += i;
                            i = i+5;
                    }
                    System.out.println(sum);
                    
                    【4】99+97+95+。。5+3+1
                    int i = 99;
                    int sum = 0;
                    while(i>=1){
                            sum += i;
                            i = i-2;
                    }
                    System.out.println(sum);
                    【5】1*3*5*7*9*11*13
                    
                    */
                    int i = 1;
                    int result = 1;
                    while(i<=13){
                            result *= i;
                            i = i+2;
                    }
                    System.out.println(result);
            }
    }

do-while

【1】语法结构：  
do \{  
循环体;  
\} while(布尔表达式) ;  
do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。do-while循环结构流程图如图所示：

![b5914fdfb7eba142ec6ec8bd6843b0b6.png][]

【2】代码：

public class TestDoWhile{
            public static void main(String[] args){
                    //1+2+3+4+...100
                    //while方式:
                    /*
                    int i = 101;
                    int sum = 0;
                    while(i<=100){
                            sum += i;
                            i++;
                    }
                    System.out.println(i);//101
                    System.out.println(sum);//0
                    */
                    //do-while方式：
                    
                    int i = 101;
                    int sum = 0;
                    do{
                            sum += i;
                            i++;
                    }while(i<=100);//一定要注意写这个分号，否则编译出错
                    System.out.println(i);//102
                    System.out.println(sum);//101
                    /*
                    【1】while和do-while的区别:
                            while:先判断，再执行
                            do-while:先执行，再判断---》至少被执行一次，从第二次开始才进行判断
                    【2】什么场合使用do-while:
                    
                    while(考试是否通过){
                            考试；
                    }
                    ---》不合适
                    do{
                            考试；
                    }while(考试是否通过);
                    ---》合适
                    */
                    
            }
    }

for

【1】语法结构：  
for (初始表达式; 布尔表达式; 迭代因子) \{  
循环体;  
\}  
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。  
初始化部分设置循环变量的初值  
条件判断部分为任意布尔表达式  
迭代因子控制循环变量的增减  
for循环在执行条件判定后，先执行的循环体部分，再执行步进。  
for循环结构的流程图如图所示：

![cea3ab98daa6b2d9cd0d662b34b38249.png][]

【2】代码：

public class TestFor01{
            public static void main(String[] args){
                    //1+2+3+..+100
                    //while:
                    /*int i = 1;
                    int sum = 0;
                    while(i<=100){
                            sum += i;
                            i++;
                    }
                    System.out.println(sum);
                    */
                    
                    //for:
                    int sum = 0;
                    int i;
                    for(i = 1;i<=100;i++){
                            sum += i;
                    }
                    System.out.println(sum);
                    System.out.println(i);
                    
                    /*
                    【1】for的结构：
                    for(条件初始化;条件判断;迭代){
                            循环体；
                    }
                    
                    【2】i的作用域：作用范围：离变量最近{}  --->可以自己去控制
                    【3】for循环格式特别灵活：格式虽然很灵活，但是我们自己写代码的时候不建议灵活着写。
                    for(;;){}  -->死循环
                    
                    int i = 1;
                    for(;i<=100;){
                            sum += i;
                            i++;
                    }
                    
                    【4】死循环：
                    for(;;){}
                    
                    while(true){}
                    
                    do{
                            
                    }while(true);
                    
                    【5】循环分为两大类：
                    第一类：当型   while(){}   for(;;){}
                    第二类：直到型  do{}while();
                    
                    【6】以后常用：for循环 
                    【7】do-while,while,for循环谁的效率高？  一样高 
                    */
            }
    }

[0b703a6e3d430e5d8a0957c8cf37a064.png]: https://img-blog.csdnimg.cn/img_convert/0b703a6e3d430e5d8a0957c8cf37a064.png
[708a529dcc980351d1253777540cf00f.png]: https://img-blog.csdnimg.cn/img_convert/708a529dcc980351d1253777540cf00f.png
[f72f5133e3b770abea43fdc2a8c9389c.png]: https://img-blog.csdnimg.cn/img_convert/f72f5133e3b770abea43fdc2a8c9389c.png
[bc184d2a445795f208152c67e6668157.png]: https://img-blog.csdnimg.cn/img_convert/bc184d2a445795f208152c67e6668157.png
[b5914fdfb7eba142ec6ec8bd6843b0b6.png]: https://img-blog.csdnimg.cn/img_convert/b5914fdfb7eba142ec6ec8bd6843b0b6.png
[cea3ab98daa6b2d9cd0d662b34b38249.png]: https://img-blog.csdnimg.cn/img_convert/cea3ab98daa6b2d9cd0d662b34b38249.png