Java 三种流程控制语句

一、顺序结构

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

    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();
        }
    }

    

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();
        }
    }

     

 

ends~