Java流程控制

一 、流程控制

1.1 流程控制的简介

程序在运行时，当执行某一个代码片段时，会有以下三种执行结构：

1.顺序结构：代码从上到下，依次执行，这种执行结构是程序运行的基本结构。

2.分支结构：代码执行到了某一个节点，遇到了多种继续执行的可能性，选择其中的一种继续向下执行。

3.循环结构：某一段代码因为某种条件，需要重复执行多次。

我们通过指定的语法，来控制程序的执行流程，这种语法就叫流程控制语法。

1.2 分支流程控制

我们可以使用if-else和switch-case等相关语法，来进行分支流程的控制。

1.2.1 if-else的基本语法

基本语法：
       if(boolean的表达式){
           //code1:    表达式返回true，执行code1
       }else{
           //code2:    表达式返回false，执行code2
        }

1.2.2 if语句的单分支演示

public class _01IfDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        if(a < b){
            System.out.println("正确");
        }else{
            System.out.println("错误");
        }
    }
}

正确

1.2.3 if的多分支语句 

语法：

if(表达式1){
     //code1
}eles if(表达式2){
     //code2
 }
 else if(表达式3){
     //code3
 }
 ......
 else{
    //code n
 }

执行逻辑：1、 先判断code1是否成立，如果成立，执行code1。
                  2、  如果code1不成立，再判断condition2，如果成立，执行code2。
                  3、如果code2不成立，再判断condition3，如果成立，执行code3。
                       .........................................
                  4、最后，如果所有的条件都不成立，执行else

public class _03IfDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请在控制台上输出一个整数：");
        int a = sc.nextInt();
        System.out.println("成绩："+a);
        if(a<0||a>100){
            System.out.println("输入有误");
        }
        else if(a>=90){
            System.out.println("优秀");
        }
        else if(a>=80){
            System.out.println("良好");
        }else if(a>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        sc.close();
    }
}

请在控制台上输出一个整数：
98
成绩：98
优秀

1.2.4 特别写法

if分支语句中，可以没有else语句块。

public class _05IfDemo {
    public static void main(String[] args) {
        //年满十八岁才可以单独进入澡堂洗澡
        int age = 20;
        if (age > 18) {
            System.out.println("可以单独进入澡堂");
        }
        System.out.println("-----------------------");
        int answer = (int)(Math.random()*10);
        System.out.println("随机出来的数字大于6");
        if(answer>3) {
            System.out.println("随机出来的数字大于3");
        }
        System.out.println("---main方法结束---");
    }
}

可以单独进入澡堂
-----------------------
随机出来的数字大于6
---main方法结束---

总结：
    1.带有else语句块分支结构，一定会执行某一条分支。
    2.不带else语句块的分支结构，可能一条分支都不执行。
    3.if分支结构不可能执行多条语句。

1.2.2 switch-case

语法：
   switch(变量/具有返回值的表达式){
       case 值1: code1;
       case 值2: code2;
        .......
       default: codeN;
}

1.变量/具有返回值的表达式： 只能是byte，short，char，int，String，枚举这些类型的表达式或者变量。
2.执行逻辑：会使用变量或表达式的值与每一个case后面的值，一一作比较。
           如果碰到完全相等的值，就执行对应对应的case后的代码块。
3.上述语法，具有分支穿透效果。如果选择了一个case分支，那么除了该分支执行完后，还会继续向下执行其他的所有分支。
4.如果带有defaule这个分支，那么如果其他case都没有对比上，则执行default分支。
5.如果不想要穿透效果，那就在每case分支后，添加break关键字。

public class _06SwitchDemo {
    public static void main(String[] args) {
        int num = (int)(Math.random()*5);
        switch(num){
            case 0:
                System.out.println("随机的是0");break;
            case 1:
                System.out.println("随机的是1");break;
            case 2:
                System.out.println("随机的是2");break;
            case 3:
                System.out.println("随机的是3");break;
            default:
                System.out.println("随机的是4");
        }
        System.out.println("---main方法结束---");
    }
}

随机的是2
---main方法结束---

如果上述代码没有在每个分支里面加break关键字，那么运行出来的结果就是：

随机的是2

随机的是3

随机的是4

因为，switch-case语句具有分支穿透效果，会继续向下执行。

1.2.3 if语句和switch语句的使用场景

1 、如果分支的条件，是一个范围，使用if。
2 、如果分支的条件，是一个值，可以使用if，也可以使用switch。

1.3 循环流程控制

当某段代码需要被多次执行，并且多次执行之间是有规律可循的。那就要使用了循环控制语句了。

循环三要素：1. 循环因子的定义和初始化
                      2. 循环条件
                      3. 循环步长：循环因子向着循环结束的方向而改变

1.3.1 for循环

(1)for循环的基本写法

语法：

                     1                           2             3

for(循环因子的声明和初始化;循环条件;循环步长){

                                    4

                               //循环体
}

执行逻辑：

              成立                                成立                            不成立

1 -----> 2 -----> 4 ------> 3 -----> 2 ------> 4 -----> 3 ------> 2 ----->结束

public class _01ForDemo {
    public static void main(String[] args) {
        /*
        使用for循环打印10次hello world
         */
        for(int i=1; i < 11; i++){
            System.out.println("Hello World");
        }
        //使用for循环，打印1到10
        for(int i=1; i < 11; i++){
            System.out.println("i:"+i);
    }
        /*使用for循环打印20以内的偶数，从2开始，包括20*/
        for(int i=2; i < 21; i+=2){
            System.out.println("i:"+i);
        }
    }
}

Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
i:1
i:2
i:3
i:4
i:5
i:6
i:7
i:8
i:9
i:10
i:2
i:4
i:6
i:8
i:10
i:12
i:14
i:16
i:18
i:20

（2）for循环的其他写法

1.for循环的小括号里除了分号，其他都可以省略。
下面的写法，三部分都省略，中间的循环条件也省略了，相当于true，即死循环，程序要避免死循环。

 for (;; ) {
     System.out.println("Hello World");
 }

2.循环因子的声明和初始化，可以写在for循环之前。

int i = 1;
        for (; i <=10; i++) {
            System.out.println("i = " + i);
        }

3.循环步长可以写在循环体中。

for(int m = 0; m <=10;) {
            System.out.println("m = " + m);
            m+=3;//循环步长
        }

4.循环条件可以不写，默认就是true。
5.循环体中只有一行代码时，可以省略花括号。if语句中，分支里面只有一行代码时，也可以省略花括号。

    for(int n = 0 ; n < 10; n++)
            System.out.println("n = " + n);

 1.3.2 while循环

 语法：

while（循环条件）{
循环体
}

执行逻辑：先执行循环条件，如果条件成立，执行循环体，再次执行循环条件，如果不成立，循环结束。

 

public class _04WhileDemo {
    public static void main(String[] args) {
            int num = 0;
            int count = 1;//定义一个变量用于统计循环的次数，也就是除以10的次数。
            while(num / 10 != 0){//判断number是不是一位数，如果不是一位数就进入循环。
                num = num / 10;
                count++;
            }
            System.out.println("是" + count +"位数");
    }
}

是1位数

1.3.3 do-while循环 

语法：

do {
// 循环体
}
while (循环条件)

特点：1、先执行一次循环体，再判断条件是否成立。
           2、如果循环条件一开始就是不成立的状态，那么也要执行一次循环体， do-while⽐while多执行一次循环体。

public class _06DoWhileDemo {
    public static void main(String[] args) {
        String realPWD = "123456";
        String inputPWD = "";
        Scanner sc = new Scanner(System.in);
        do{
            System.out.println("请输入密码");
            inputPWD = sc.nextLine();
        }while(!realPWD.equals(inputPWD));
        System.out.println("密码正确");
    }
}

该方法可以无限输入密码，直到密码正确为止。 

请输入密码
031020
请输入密码
134562
请输入密码
123456
密码正确

1.3.4 使用场景

for，while，do-while的应用场景或者区别 

1. for循环适合知道循环次数的场景。

2. while循环适合不知道循环次数，但是知道循环的条件的场景 。

3. do-while循环适合先执行循环体再判断条件的场景。比如：做一件事，直到什么时候结束。

1.3.5 关键字

（1）Break

break：打断，毁坏的含义。 在循环结构中，表示打断，跳过，结束循环。继续向下执行后续代码。 注意：break只能结束其所在的的循环结构。

public class _07BreakDemo {
    public static void main(String[] args) {
        //从1开始打印到100，如果打印遇到10，就结束循环
        for (int i = 1; i <= 100; i++) {
            System.out.println(i);
            if (i  == 10) {
                break;
            }
        }
        System.out.println("-----后续代码-----");
        /* 猜数字游戏的模拟 */
        Scanner sc = new Scanner(System.in);
        //一个同学在手机上输入的数字，开始猜这个数字
        int answer = (int)(Math.random()*10);
        while(true){
            System.out.println("请继续猜");
            int guess = sc.nextInt();
            if(guess == answer){
                System.out.println("猜对了");
                break;
            }else if(guess > answer){
                System.out.println("猜大了，请往小猜");
            }else{
                System.out.println("猜小了，请往大猜");
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
-----后续代码-----
请继续猜
5
猜小了，请往大猜
请继续猜
8
猜对了

（2）contiue

continue这个单词是继续的含义。

表示在循环结构中表示中止打断本次循环，继续下一次的循环。

public class _08ContinueDemo {
    public static void main(String[] args) {
        //需求1：计算100以内的偶数之和，排除50
        int sum = 0;//用于累加
        for (int i = 1; i < 101; i++) {
            if (i % 2 == 0) {
              if(i==50){
                  continue;//表示当i=50时，中止sum+=i这个操作，继续下一次循环。这样就排除了50。
              }
              sum += i;
        }
        }
        System.out.println("sum的结果"+sum);
    }
}

sum的结果2500

1.4 循环的嵌套

1. 循环结构是可以进行多层次嵌套的。
2. 在生产环境中，尽量不要使用循环嵌套，因为非常耗性能。

执行逻辑：外层循环执行一次，内层循环执行一遍(从循环开始到循环结束)。

public class _09NestOfLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i="+i);
            for (int j = 0; j <3 ; j++) {
                System.out.println("j="+j);
            }
        }
        System.out.println("----循环结束----");
    }
}

i=0
j=0
j=1
j=2
i=1
j=0
j=1
j=2
i=2
j=0
j=1
j=2
i=3
j=0
j=1
j=2
i=4
j=0
j=1
j=2
----循环结束----