Java第四天：循环结构

一：While：

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

【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 TestWhile{
        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】循环四要素：

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

【3】循环的执行过程：
【4】验证循环的执行过程（idea中调试）：

二：do while语句：

 【1】语法结构：
do {
            循环体;
    } while(布尔表达式) ;

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

 

 【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循环结构的流程图如图所示：

【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循环谁的效率高？  一样高 
                */
        }
}

 PS:看我整理得这么辛苦，关注一下我呗，顺便点个赞，求求了，这对我很重要，大佬们请见证我的成长吧！