java循环结构

男娘i 2024-03-17 10:11 47阅读 0赞

### 精华笔记： ###

1.  循环：反复多次执行一段相同或相似的代码
2.  循环三要素：重点
    
     *  循环变量的初始化
     *  循环的条件(以循环变量为基础)
     *  循环变量的改变(向着循环的结束变)
        
        > 循环变量：在整个循环过程中所反复改变的那个数
3.  循环结构(上)：
    
     *  while结构：先判断后执行，有可能一次都不执行
     *  do…while结构：先执行后判断，至少执行一次
        
        > 建议：当第1要素与第3要素的代码相同时，首选do…while
4.  循环结构(下)：
    
     *  for结构：应用率高，与次数相关的
5.  三种循环结构如何选择：
    
     *  先看循环是否与次数有关：
        
         *  若有关---------------------------------------------------------直接上for
         *  若无关，再看要素1与要素3的代码是否相同：
            
             *  若相同---------------------------------------------------直接上do…while
             *  若不同---------------------------------------------------直接上while
6.  break：跳出循环
    
    continue：跳过循环体中剩余语句而进入下一次循环
7.  嵌套循环：
    
     *  循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
     *  执行规则：外层循环走一次，内层循环走所有次
     *  建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层
     *  break只跳出当前一层循环

### 笔记 ###

1.  循环：反复多次执行一段相同或相似的代码
2.  循环三要素：重点
    
     *  循环变量的初始化
     *  循环的条件(以循环变量为基础)
     *  循环变量的改变(向着循环的结束变)
        
        > 循环变量：在整个循环过程中所反复改变的那个数
        
            1)输出5次"行动是成功的阶梯":
                行动是成功的阶梯
                行动是成功的阶梯
                行动是成功的阶梯
                行动是成功的阶梯
                行动是成功的阶梯
              循环变量:次数times
              1)int times=0;
              2)times<5
              3)times++;
                times=0/1/2/3/4/ 5时结束
                    
            2)输出9的乘法表:
                1*9=9
                2*9=18
                3*9=27
                4*9=36
                5*9=45
                6*9=54
                7*9=63
                8*9=72
                9*9=81
             循环变量:因数num
             1)int num=1;
             2)num<=9
             3)num++;
               num=1/2/3/4/5/6/7/8/9/ 10时结束
                   
                1*9=9
                3*9=27
                5*9=45
                7*9=63
                9*9=81
             循环变量:因数num
             1)int num=1;
             2)num<=9
             3)num+=2;
               num=1/3/5/7/9/ 11时结束
3.  循环结构(上)：
    
     *  while结构：先判断后执行，有可能一次都不执行
        
            1)语法:
              while(boolean){
                    
                语句块/循环体------------反复执行的代码
              }
            2)执行过程:
                先判断boolean的值，若为true则执行语句块，
                再判断boolean的值，若为true则再执行语句块，
                再判断boolean的值，若为true则再执行语句块，
                如此反复，直到boolean的值为false时，while循环结束
        
            //1)输出5次"行动是成功的阶梯":
            int times = 0;  //1)循环变量的初始化
            while(times<5){
                     //2)循环的条件
                System.out.println("行动是成功的阶梯");
                times++;    //3)循环变量的改变
            }
            System.out.println("继续执行...");
            /*
             执行过程:------带数
                          times=0
               true  输出  times=1
               true  输出  times=2
               true  输出  times=3
               true  输出  times=4
               true  输出  times=5
               false while循环结束
               输出继续执行...
            */
            //2)输出9的乘法表:
            int num = 1;
            while(num<=9){
                    
                System.out.println(num+"*9="+num*9);
                num+=2; //num++;
            }
            System.out.println("继续执行...");
        
            package day04;
            import java.util.Scanner;
            //猜数字小游戏
            public class Guessing {
                    
                public static void main(String[] args) {
                    
                    Scanner scan = new Scanner(System.in);
                    int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
                    System.out.println(num); //作弊
            		
                    //300(大),200(小),250(对)
                    System.out.println("猜吧!");
                    int guess = scan.nextInt(); //1
                    while(guess!=num){
                     //2
                        if(guess>num){
                    
                            System.out.println("太大了");
                        }else{
                    
                            System.out.println("太小了");
                        }
                        System.out.println("猜吧!");
                        guess = scan.nextInt(); //3
                    }
                    System.out.println("恭喜你猜对了!");
                }
            }
     *  do…while结构：先执行后判断，至少执行一次
        
        > 建议：当第1要素与第3要素的代码相同时，首选do…while
        
            1)语法:
              do{
                    
                语句块
              }while(boolean);
            2)执行过程:
                先执行语句块，再判断boolean的值，若为true则
                再执行语句块，再判断boolean的值，若为true则
                再执行语句块，再判断boolean的值，若为true则
                再执行语句块，如此反复，直到boolean的值为false时，do...while结束
        
            package day04;
            import java.util.Scanner;
            //猜数字小游戏
            public class Guessing {
                    
                public static void main(String[] args) {
                    
                    Scanner scan = new Scanner(System.in);
                    int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
                    System.out.println(num); //作弊
            
                    //假设num=250
                    //300(大),200(小),250(对)
                    int guess;
                    do{
                    
                        System.out.println("猜吧!");
                        guess = scan.nextInt(); //1+3
                        if(guess>num){
                    
                            System.out.println("太大了");
                        }else if(guess<num){
                    
                            System.out.println("太小了");
                        }else{
                    
                            System.out.println("恭喜你猜对了");
                        }
                    }while(guess!=num); //2
                }
            }
4.  循环结构(下)：
    
     *  for结构：应用率高，与次数相关的
        
            1)语法:
              //    1      2       3
              for(要素1 ; 要素2 ; 要素3){
                    
                语句块/循环体---------------反复执行的代码   4
              }
            2)执行过程:
                1243243243243243...2
        
            //for中的循环变量num的作用域，仅在当前for中----特殊情况特殊记
            for(int num=1;num<=9;num++){
                    
                System.out.println(num+"*9="+num*9);
            }
            for(int num=1;num<=9;num+=2){
                    
                System.out.println(num+"*9="+num*9);
            }
            for(int num=9;num>=1;num--){
                    
                System.out.println(num+"*9="+num*9);
            }
            for(int times=0;times<5;times++){
                    
                System.out.println("行动是成功的阶梯");
            }
            System.out.println("继续执行...");
            */
            /*
                执行过程:
                times=0  true  输出
                times=1  true  输出
                times=2  true  输出
                times=3  true  输出
                times=4  true  输出
                times=5  false for循环结束
                输出继续执行...
            */
        
            package day05;
            import java.util.Scanner;
            //随机加法运算器
            public class Addition {
                    
                public static void main(String[] args) {
                    
                    Scanner scan = new Scanner(System.in);
                    int score = 0; //总分
                    for(int i=1;i<=10;i++){
                     //10次
                        int a = (int)(Math.random()*100); //加数a(0到99之间的)
                        int b = (int)(Math.random()*100); //加数b(0到99之间的)
                        int result = a+b; //存正确答案
                        System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
            
                        System.out.println("算吧!");
                        int answer = scan.nextInt(); //2)答题
            
                        if(answer==-1){
                     //退出的条件只要不是0到198都可以
                            break;
                        }
                        if(answer==result){
                     //判题
                            System.out.println("答对了");
                            score += 10; //答对1题，加10分
                        }else{
                    
                            System.out.println("答错了");
                        }
                    }
                    System.out.println("总分为:"+score);
                }
            }
5.  三种循环结构如何选择：
    
     *  先看循环是否与次数有关：
        
         *  若有关---------------------------------------------------------直接上for
         *  若无关，再看要素1与要素3的代码是否相同：
            
             *  若相同---------------------------------------------------直接上do…while
             *  若不同---------------------------------------------------直接上while
6.  break：跳出循环
    
        for(int num=1;num<=9;num++){
              
            if(num==4){
               //在某种特定条件下，提前结束循环
                break; //跳出循环
            }
            System.out.println(num+"*9="+num*9);
        }
        
        /*  执行过程:
            num=1  1*9=9
            num=2  2*9=18
            num=3  3*9=27
            num=4
        */
    
    continue：跳过循环体中剩余语句而进入下一次循环
    
        //输出9的乘法表，只要不能被3整除的
        for(int num=1;num<=9;num++){
              
            if(num%3!=0){
              
                System.out.println(num+"*9="+num*9);
            }
        }
        
        //输出9的乘法表，跳过能被3整除的
        for(int num=1;num<=9;num++){
              
            if(num%3==0){
              
                continue; //跳过循环体中剩余语句而进入下一次循环
            }
            System.out.println(num+"*9="+num*9);
        }
          
        /*  执行过程:
            num=1  1*9=9
            num=2  2*9=18
            num=3
            num=4  4*9=36
            num=5  5*9=45
            num=6
            num=7  7*9=63
            num=8  8*9=72
            num=9
            num=10 false
        */
7.  嵌套循环：
    
     *  循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
     *  执行规则：外层循环走一次，内层循环走所有次
     *  建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层
     *  break只跳出当前一层循环
        
            public class MultiTable {
                    
                public static void main(String[] args) {
                    
                    for(int num=1;num<=9;num++){
                     //控制行
                        for(int i=1;i<=num;i++){
                     //控制列
                            System.out.print(i+"*"+num+"="+i*num+"\t");
                        }
                        System.out.println(); //换行
                    }
                    /*
                      执行过程:
                        num=1
                          i=1   1*1=1
                          i=2   false
                          换行
                        num=2
                          i=1   1*2=2
                          i=2   2*2=4
                          i=3   false
                          换行
                        num=3
                          i=1   1*3=3
                          i=2   2*3=6
                          i=3   3*3=9
                          i=4   false
                          换行
                     */
                }
            }

### 补充： ###

1.  生成随机数：
    
        Math.random()-----------0.0到0.9999999999999999...
        *1000-------------------0.0到999.99999999999999...
        +1----------------------1.0到1000.9999999999999...
        (int)-------------------1到1000
2.  变量的作用域/范围：
    
     *  从变量的声明开始，到包含它最近的大括号结束
3.  变量的重名：
    
     *  作用域重叠时，变量不能同名
4.  \\t：水平制表位，固定占8位
5.  默认值规则：
    
        byte,short,int,long,char-----------------0
        float,double-----------------------------0.0
        boolean----------------------------------false