Java 三种流程控制语句

港控/mmm° 2022-01-07 01:33 264阅读 0赞

### 一、顺序结构 ###

如果代码里没有流程控制，程序从上到下按照书写的格式依次执行。

public static void main(String[] args) {
            int result = 1;
            result = result++;
            System.out.println("result=" + result); //1
            int result2 = 1;
            result2 = ++result2;
            System.out.println("result2=" + result2); //2
        }

### 二、选择结构 ###

通过判断条件来做选择的语句，称为选择语句或分支语句。有 if和 switch两种结构

**1、if语句**

1）if语句

/*
         * if语句：
         *     if(关系表达式){
         *        语句体；
         *     }
         * 执行流程：
         *    1.计算关系表达式的值，看结果是true还是false；
         *    2.若是true则执行语句体；
         *    3.若是false则不执行语句体
         */
        public static void main(String[] args) {
            if(10 == 10){
                System.out.println("两个数相等");
            }
        }

2）if-else语句

/*
         * if-else语句：
         *     if(关系表达式){
         *        语句体1;
         *     }else{
         *        语句体2;
         *     }
         * 执行流程：
         *    1.计算关系表达式的值，看结果是true还是false；
         *    2.若是true则执行语句体1；
         *    3.若是false则执行语句体2
         */
        public static void main(String[] args) {
            if(10 < 10){
                System.out.println("10 < 10");
            }else{
                System.out.println("10 不小于 10");
            }
            // 输出：10 不小于 10
        }

3）if-else if-else语句

/*
         * if-else if-else语句：
         *     if(关系表达式1){
         *        语句体1;
         *     }else if(关系表达式2){
         *        语句体2;
         *     }else{
         *         语句体3;
         *     }
         * 执行流程：
         *    1.计算关系表达式1的值，看结果是true还是false；
         *    2.若是true则执行语句体1；
         *    3.若是false则计算关系表达式2的值，看结果是true还是false；
         *    4.若是true则执行语句体2；
         *    5.若是false则执行语句体3；
         */
        public static void main(String[] args) {
            if(10 < 10){
                System.out.println("10 < 10");
            }else if(10 > 10){
                System.out.println("10 < 10");
            }else if(10 == 10){
                System.out.println("10 == 10");
            }else {
                System.out.println("其他");
            }
            // 输出：10 == 10
        }

2、switch语句

switch语句的语法结构与 if-else if-else语句的语义相同；

注意：表达式只可以是 byte,short,char,int，**没有long类型；jdk5以后支持 枚举类型，jdk7以后支持 String类型。**

/*  switch语句：
         *  switch(表达式){
         *      case 值1:
         *              语句体1; break;
         *      case 值2:
         *              语句体2; break;
         *      ...
         *      default:
         *              语句体n+1;
         *              break; // 一般不写
         *  }
         * 执行流程：
         *    1.计算表达式的值；
         *    2.将得到的值依次与case后的值进行匹配，一旦匹配成功则执行相应的语句体，遇到break则结束；
         *    3.若是都不匹配，则执行语句体n+1,则结束；
         */
        public static void main(String[] args) {
            switch ('C'){
                case 'A':
                    System.out.println("A"); break;
                case 'c':
                     System.out.println("小c"); break;
                case 'C':
                    System.out.println("大C"); break;
                default:
                    System.out.println("其他");
            }
            // 输出：大C
        }

**3、if 和 switch都是选择语句/条件语句，如何选择？**

1）对于所有的条件语句,if都可以完成.

2）swtich语句,只能针对于结果为数值或字符串情况做判断.

3）当if中条件的结果是数值时,使用switch语句更简单.

### 三、循环结构 ###

1、for循环

/*
         * for循环语句：
         *   for(初始化语句; 判断条件语句; 控制条件语句){
         *      循环体语句;
         *   }
         * 执行流程：
         *   1.执行初始化语句;
         *   2.执行判断条件语句;
         *   3.执行循环体语句;
         *   4.执行控制条件语句;
         *   5.回到2在开始执行，直至不符合控制条件语句.
         */
        public static void main(String[] args) {
            int sum = 0;
            for(int i=1; i<=10; i++){
                sum+=i;
            }
            System.out.println("sum:"+sum);
            // 输出：55
        }

2、while循环

注意: 先判断条件语句（ boolean表达式）。

/*
         * while循环语句：
         *      while(判断条件语句){
         *          循环体语句;
         *          控制条件语句;
         *      }
         * 执行流程：
         *   1.执行判断条件语句;
         *   2.执行循环体语句;
         *   3.执行控制条件语句;
         *   4.回到1在开始执行，直至不符合控制条件语句.
         */
        public static void main(String[] args) {
            int sum = 0;
            int i = 1;
            while(i <= 10){
                sum+=i;
                i++;
            }
            System.out.println("sum:"+sum);
            // 输出：55
        }

3、do…while循环

注意: 不管判断条件语句（boolean表达式）的结果是 true 还是 false，先执行一次循环体，即：**无论条件如何，do...while的循环体语句至少会执行一次。**

/*
         * do...while循环语句：
         *      do{
         *          循环体语句;
         *          控制条件语句;
         *      }while(判断条件语句);
         * 执行流程：
         *   1.执行循环体语句;
         *   2.执行控制条件语句;
         *   3.执行判断条件语句;
         *   4.回到1在开始执行，直至不符合控制条件语句.
         */
        public static void main(String[] args) {
            int sum = 0;
            int i = 1;
            do{
                sum+=i;
                i++;
            }while(i <= 10);
            System.out.println("sum:"+sum);
            // 输出：55

**4、三种循环体的区别**

1）do…while循环至少会执行一次循环体，for和while循环只有在判断条件成立时才会执行循环体。

2）for循环结束后初始化的变量不能继续使用，而while和do…while循环结束后初始化的变量可以继续使用，即：for循环效率更高（释放变量存储内存）。

**5、循环之间可以嵌套循环**

/*
         * 99乘法表
         */
        public static void main(String[] args) {
            for (int i = 1; i <= 9; i++) {
                for (int j = 1; j <= i; j++) {
                    System.out.print(j + " * " + i + " = " + (j * i) + "\t");
                }
                System.out.println();
            }
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

**6、控制循环结束语句**

Java提供了**break，continue**和**return**语句来实现控制语句的跳转和中断。在某个循环执行到某一步的时候就结束。

1）break语句

表示结束当前所在的循环.

**注意**：break之后的语句,执行不到,若编写了,则语法报错.

2）continue语句:

表示跳过当前循环,继而进行下一次循环.

**注意**：continue之后的语句,执行不到,若编写了,则语法报错.

3）return语句:

表示结束循环所在的方法，方法都结束了，循环结构自然也就结束了。

**4）控制外层循环:**

此时就得使用标签(给某个循环起个别名)，不过该别名得满足标识符的规范。

若要控制外层循环，就在break或continue后面跟上循环的别名就OK了

public static void main(String[] args) {
            outer : for (int i = 1; i <= 9; i++) {
                if(i == 4){
                    continue; // 跳过当前循环,继而进行下一次循环
                }
                for (int j = 1; j <= i; j++) {
                    if(i == 6){
                       break outer; // 结束外层循环
                    }
                    System.out.print(j + " * " + i + " = " + (j * i) + "\t");
                }
                System.out.println();
            }
        }

![20190625110402893.png][]

ends~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20211227/23abc9929d664184b12e7025f68df864.png
[20190625110402893.png]: https://img-blog.csdnimg.cn/20190625110402893.png