Java流程控制、循环、嵌套循环案例（此节重点掌握！！！）

一、流程控制

1、定义

​ 在一个Java程序中，各条语句的执行对程序的结果有直接影响，也就是说 个语句的执行顺序对程序的结果有直接影响

​ 在程序中，可能出现不同的执行顺序，必须自上而下顺序执行，或者条件判断的顺序，或者循环执行的顺序

2、分类

1. 顺序执行

//顺序执行，自上而下执行代码
public static void main(String[] args){
System.out.println(1);
System.out.println(2)；
System.out.println(3);

2. 条件分支

2.1、if条件分支

​ 语法：

if(条件){
    语句块
}其他代码

解释：如果条件成立，则执行语句块，如果条件不成立，则不执行语句块

2.2、if...else条件分支

​ 语法

if(条件){
    语句块1
}else{
    语句块
}

解释：如果条件成立，则执行语句块1，如果条件不成立，则执行语句块2

 //一个程序员去买菜，如果看到西瓜就买一个，如果看到葡萄就买葡萄
        int n=(int)(Math.random()*100);
        //n<50  需要买西瓜   >50  需要买葡萄
        if(n<50){
            System.out.println("买了一个大西瓜");
        }else{
            System.out.println("买了一串葡萄");
        }
        System.out.println("n->"+n);
        System.out.println("嗯，程序猿的女朋友很高兴，至少买到水果了");

2.3、if...else if...else多条件分支

if（条件1）{
    语句块1
}else if（条件2）{
    语句块2
}else if（条件3）{
    语句块3
}else{
    语句块4
}

解释：从条件1开始依次判断，如果条件1成立，则执行语句块1，其他条件不再执行，如果条件2成立，则执行语句块2，其他条件不再执行。。。依次类推如果条件都不成立，则执行else语句块，最终只执行其中一条语句块

​

        //随机生成90以内的年龄  整数
        int n= (int)(Math.random()*90);
        if(n<18){
            System.out.println("未成年");
        }else if (n<30){
            System.out.println("青年");
        }else if (n<50){
            System.out.println("中年");
        }else if (n<70){
            System.out.println("老年");
        }else{
            System.out.println("晚年");
        }
        System.out.println("n->"+n);
    }

2.4、嵌套条件判断

​ 语法：以上三条同时使用，在一个if语句中在嵌套一个if语句

    //接受控制台输入  判断 输入的数  是否能被3整除
    //如果能被3整除，输出这个数除以3的结果，并判断结果能被7整除
    //如果不能被3整除，判断是否为偶数
        Scanner sc=new Scanner(System.in);
        //接受控制台输入的整数
        int n=sc.nextInt();
        if (n%3==0){
            System.out.println("这个数能被3整除");
            //在if语句中继续判断，就是嵌套条件判断，然后往后缩进
            int result=n/3;
            if (result%7==0){
                System.out.println("这个数能被7整除");
            }else{
                System.out.println("这个数不能被7整除");
            }
        }else {
            System.out.println("这个数不能被3整除");
            if (n%2==0){
                System.out.println("这个数不能被2整除");
            }else {
                System.out.println("这个数能被2整除");
            }
        }

注意：嵌套条件是为了增强代码的可读性，将条件语句块向后缩进，{}作为一个整体，条件语句块如果只有一个可以省略缩进

3. 选择条件判断switch

switch(switch(表达式){
    case 常量值1;
    	语句块1;
    	break;  //语句块接受的标记
    case 常量值2;
    	语句块2;
    	break;
    ...
    defaul;
    	语句块3;
    	break;
}
```   
}

   public static void main(String[] args) {
    //柑橘数字判断星期几   iny
    int n=(int)(Math.random()*7+1);
    switch (n){
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        default::
            System.out.println("星期天");
            break;
    }

注意：switch的表达式判断只能等值比较，其中case的常量值，类型为（byte int shrot）字符型，字符串型，枚举型

// case 中可以是字符 或字符串
String s="hello";
switch(s){
    case "hello":
        System.out.println("你好");
        break;
    case "hi":
        System.out.println("嗨");
}

case穿透问题

在switch中，如果case后面不屑break，将会出现穿透现象也就是说不会执行下一个case的判断条件，直接往后运行，直到遇到break，或整体switch结束

二、循环

1、循环定义

​ 在Java程序中，重复的执行某一代码，这个过程称之为循环，为了避免出现死循环，循环分为四个部分：

1. 初始条件

2. 循环的判断条件，条件为true，则进入循环体

3. 循环体

4. 迭代变量

   

while循环

语法：

  初始条件
  while(判断条件){
      循环体
      迭代部分 （为了改变循环的判断条件）
  }

例题： 计算1到100的累计之和 1+2+3+4...+100=?

初始值 n=  1
条件：  100以内的 数可以一直累加（一直循环）
迭代： n++ 
 //计算 1到100的累加之和
        int sum=0;
        int  n=1;
        while(n<=100){
            sum+=n;
            n++;
        }
        System.out.println("n:"+n);
        System.out.println("sum:"+sum);

如果知道循环的次数：
    int i = 0;
	while(i < x){
        i++;
    }
    //循环x遍
    
如果不知道循环的次数：
    boolean flag = true;
	while(flag){
      
        if(达到条件){
            flag = false;
        }
        
    }   

do...while循环

语法：

 初始值1
 do{
     循环体2
     迭代部分3
 }while(返回boolean类型的表达式4)；

执行顺序： 123-》423 -》423-》423 .。。4 直到条件4为false 则退出循环。

​ 先执行初始值 1，循环体2 ，迭代3

​ 再判断条件4是否成立，成立，继续执行2，3

再判断条件4是否成立，成立，继续执行2，3

...

​ 判断条件4是否成立，不成立，退出

        int i=0;
          do{
              System.out.println("i--"+i);
              i++;
          }while(i<10);

        System.out.println("i===="+i);
        /**
         * 第一遍： 输出 0   i=1
         * 第二遍： 判断 1<10  成立  输出1   i=2
         * 第三遍： 判断 2<10  成立  输出2   i=3
         * .。。
         * 第九遍： 判断8<10  成立  输出8   i=9
         * 第十遍：判断 9<10  成立 输出9    i=10
         * 第十一遍: 判断 10<10 不成立。退出
         *
         *
         */

面试题： while循环与do while循环的区别?

• while 先判断后执行，do—while是先执行后判断
• do—while总是保证循环体会被至少执行依次！这是他们的主要区别

for循环

​ for循环的升级版就是 foreach循环

​ for循环通常在明确循环次数的情况下使用

语法

 for(初始值1 ; 循环判断条件2 ; 迭代部分3 ){
     循环体4
 }
 或者
  
 初始值
 for( ; 循环判断条件 ; ){
     
     循环体
     
     迭代部分
 }
 // 他们的区别是 初始值定义在for的外边，就可以在循环外边使用

循环执行流程：

​ 1243-》243-》243-》243-》。。。》2 为false 循环退出

例如 ：循环输出5遍hello world

  // i 表示计数器，从1开始 到5结束
 for(int i=1 ;i<=5 ; i++){
      System.out.println("hello world");
  }
  循环的执行顺序：   

//第一遍： i=1    1<5    成立 输出“hello world ”   i++   i=2

//第二遍 ：2<=5 成立  输出“hello world”  i=3

//第三遍 ： 3<=5 成立  输出”hello world“ i=4

//第四遍： 4<=5成立  输出”hello world“ i=5

//第五遍： 5<=5 成立  输出”hello world“ i=6

//第六遍： 6<=5 不成立，退出 

//i=6 

使用for循环计算10的阶乘

 // 使用for循环 计算 10的阶乘
	int sun=0;
        for(int i=1;i<=10;i++){
            sum*=i;
        }
	System.out.println("10的阶乘:"+sum);

for循环部分可以省略

        // 死循环
        for(;;){
            System.out.println("hello");
        }
        // 死循环
        for(;;){
            System.out.println("hello");
        }

for循环的迭代部分可以放在 循环体中

  // 迭代部分的代码 可以 放入循环体中
  int i=0;
  for( ; i<10; ){
  System.out.println("第"+i+"次输出");
  i++;
  }

for循环的特点

​ for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构

​ for循环执行的次数是在执行器那就确定的。

三、关键字break、continue、return的区别

1.break：用于switch...case中防止语句块穿透

​ 用于跳出循环

        //从1到7  遇到7的倍数break
        for(int i=1;i<100;i++){
            //遇到7跳出
            if (i%7==0){
                break;
            }
            System.out.println("i---"+i);
        }

1. continue：跳出本次循环，继续下一次循环

          for (int i=0;i<100;i++){
               if (i%7==0){
                   continue; //跳出本次循环  继续下一次循环
               }
               System.out.println("i----"+i);
           }
       }
   

面试题：break 和 continue的区别

• break在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）

• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

1. return：返回本次方法

   用法1：如果return放置在循环中，会跳出循环，且不会执行循环外面的语句

   用法2：作为方法的返回值

   用法3：无论方法是否有返回值，可以在条件判断的位置 直接return

   return和break再循环语句块是，break只是结束循环语句块，对于循环外面的代码会执行，而return是结束当前所在方法的剩下的语句块。

     public static void main(String[] args) {
              for(int i = 1;i<100;i++) {
                  if (i == 50) {
                      return;
                  }
                  System.out.println("i----"+i);
              }
   
             System.out.println("程序结束");
   
       }
     public void method1(){
            // return 还可以在条件判断的位置 直接返回方法
           int n = (int)(Math.random()*10);
           if(n%2 ==0){
               return  ; // 方法的后面就不再运行
           }
           System.out.println("方法的其他代码块");
           
       }
   

   结论：只要执行return，那么它后面的代码都不执行。

       public int add(){
           return 0;
          
       }
   

   return作为方法返回值的关键字

四、以嵌套循环为案例

嵌套循环：在一个循环语句中。还包含了另外一个循环，例如在一个for循环中还有一个for循环，

它的总循环次数=外循环的次数*内循环次数

语法

for（）{//外循环
    for（）{内层循环
        
    }
}

执行顺序：外层循环循环依次，内层循环循环完整的一遍

*   
*   *   
*   *   *   
*   *   *   *   
*   *   *   *   *  
public static void main(String[] args) {
        //for
        for (int j=1;j<=5;j++) {
            for (int i = 0; i < j; i++) {
                System.out.print("*   ");
            }
            System.out.println();
        }
    }

    *
   ***
  *****
 *******
*********
public static void main(String[] args) {
        int j = 1;
        for (int k = 5; k <= 9; k++) {
            for (int i = 0; i < k; i++) {

                if (i < k - j) {
                    System.out.print(" ");
                } else {
                    System.out.print("*");
                }
            }
            j += 2;
            System.out.println();
        }
    }

        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *
  * * * * * * *
    * * * * *
      * * *
        *
思路 : 考虑一行打多少个空格 多少个* 

一共5 行     空格的个数（5-i）  *的个数 （2 *  i  -  1）

i=1			4				1  

i=2			3               3

i=3			2               5

i=4			1               7  

i=5			0				9  
      public static void main(String[] args) {

//        上半角
        for (int j = 1; j < 5; j++) {
            for (int k = 0; k < 4 - j; k++) {
                System.out.print("  ");
            }
            for (int i = 0; i < 2 * j - 1; i++) {
                System.out.print("* ");
            }
            System.out.println();
        }
//        下半角
        for (int j = 3; j >0; j--) {
            for (int i = 0; i < 4-j; i++) {
                System.out.print("  ");
            }
            for (int k = 0; k < 2*j-1; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }