Java流程控制语句总结

我们知道任何语言程序执行是有一定顺序性的，所以我们使用控制语句来实现对程序流程的选择、循环、转向和返回等进行控制，

特别是在循环语句中，它解决了重复算法浪费代码空间和代码整洁度的问题。同时语言是有结构层次之分的，所以我们来

顺序结构

顺序结构的程序设计是最简单的，只需按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。也是一种宏观条件下的代码结构。

                                                                                                 

 选择结构

选择结构用于判断给定的条件，根据判断的结果判断某些条件，根据判断的结果来控制程序的流程。

• if语句

 

 

• switch语句

switch语句是开关语句，一般与case、break、default配合使用，对流程进行控制。一般用于多条件选择。

和if语句的区别是：if语句既可以对一个单一的值进行判断，也可以对一个区间的值进行判断，而switch只能判断单一的值。

switch所要求的变量的数据类型：byte short int char String 枚举

 

循环结构

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。常用的有for循环、while循环、do while 循环。

循环的四要素：1.循环初始化（循环起始位置）

                             2.循环继续的条件（循环终止条件）

                             3.循环体（需要多次重复执行的代码块）

                             4.循环的周期（当前循环和下一次循环之间的变更）

一般来说，当我们确定这四个部分就能写出一个循环代码段。

嵌套循环：当外层执行一次，里层需执行一次或多次。好比与一年上365天的学，1-365天的循环就是外层，每天上学8小                         时，1-8就是里层。

• for循环

for循环一般用于已知重复次数的循环。

基本格式：for(1循环的初始化 ;  2循环的继续条件 ; 4循环的步长 ){
         3循环体
}

通过一段代码说明：

class Test{
    public static void main(String[] args){
        /* 
        ********
        思路：将一个*重复输出八次即可
        */
        for(int i=1;i<=8;i++){
            System.out.print("*");
        }
        System.out.println("=======================");
        /*
        ********
        ********
        ********
        ********
        思路：首先将*循环输出8次打出一行的*，然后再将一行循环4次打出四行。
        */
        //嵌套循环
        for(int line=1;line<=4;line++){
            for(int i=1;i<=8;i++){
                System.out.print("*");
            }
            System.out.println();
        }
        /* 
            *           1
            **          2
            ***         3
            ****        4
            *****       5
            *******     6
            ********    7
        思路：同样先输出每行的*，观察到每行的*数就是行数，每行输出行数个*即可，重复执行7次即可输出7行。
        */
        for(int line=1;line<=7;line++){
            for(int i=1;i<=line;i++){
                System.out.print("*");
            }
            System.out.println();
        }
        /*              i   j
            *           1   1
            **          2   1 2
            ***         3   1 2 3
            ****        4   1 2 3 4
            *****       5   1 2 3 4 5
            ******      6   1 2 3 4 5 6
            *****       7   1 2 3 4 5 
            ****        8   1 2 3 4
            ***         9   1 2 3
            **          10  1 2
            *           11  1
            j<=i && j<=12-i
            思路：一行一行的输出，发现每行的*先递增后递减
            递增时每行的*数是行数，递减时每行*数是总行数+1-当前行数
            将两个条件用&&连接起组成一个控制条件。
        */
        for(int i=1;i<=11;i++){
            for(int j=1;j<=i&&j<=12-i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        /*          k=|i-6| |k| 当前行的最大的空格数
                    k    i   j
                 * -5    1   1
                ** -4    2   1 2
               *** -3    3   1 2 3
              **** -2    4   1 2 3 4
             ***** -1    5   1 2 3 4 5
            ******  0    6   1 2 3 4 5 6
             *****  1    7   1 2 3 4 5 
              ****  2    8   1 2 3 4
               ***  3    9   1 2 3
                **  4    10  1 2
                 *  5    11  1
            思路：该图形只是在上个图案最前面上加了空格，空格的数量是先减后增
                  而且符合y=|x|，所以只需在输出上一个图案的代码之前添加空格即可。
        */
        for(int i=1;i<=11;i++){
            for(int k=1;k<=Math.abs(i-6);k++){
                System.out.print(" ");
            }
            for(int j=1;j<=i&&j<=12-i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        /*          k=|i-6| |k| 当前行的最大的空格数
                            k    i   j
                 *         -5    1        1
                * *        -4    2       1 2
               * * *       -3    3      1 2 3
              * * * *      -2    4     1 2 3 4
             * * * * *     -1    5    1 2 3 4 5
            * * * * * *     0    6   1 2 3 4 5 6
             * * * * *      1    7    1 2 3 4 5 
              * * * *       2    8     1 2 3 4
               * * *        3    9      1 2 3
                * *         4    10      1 2
                 *          5    11       1
            思路：此图案和上个图每行的*一样，仔细观察就是让每个*后面加一个空格即可。
        */
        for(int i=1;i<=11;i++){
            for(int k=1;k<=Math.abs(i-6);k++){
                System.out.print(" ");
            }
            for(int j=1;j<=i&&j<=12-i;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
        /*          k=|i-6| |k| 当前行的最大的空格数
                            k    i   j
                 *         -5    1        1
                * *        -4    2       1 2
               *   *       -3    3      1 2 3
              *     *      -2    4     1 2 3 4
             *       *     -1    5    1 2 3 4 5
            *         *     0    6   1 2 3 4 5 6
             *       *      1    7    1 2 3 4 5 
              *     *       2    8     1 2 3 4
               *   *        3    9      1 2 3
                * *         4    10      1 2
                 *          5    11       1
                j==1 j==i j+i==12
            思路：是上个图形中间掏空的形式，留了四条边，左边两条边刚好是每行第一次输出的*
                  右上的边和右下的边不是一个规律所以分两种，右上是行数，右下是行数+最大*数
        */
        for(int i=1;i<=11;i++){
            for(int k=1;k<=Math.abs(i-6);k++){
                System.out.print(" ");
            }
            for(int j=1;j<=i&&j<=12-i;j++){
                if(j==1||j==i||j+i==12){
                    System.out.print("* ");
                }else{
                    System.out.print("  ");
                }
            }
            System.out.println();
        }
    }
}

 

• while循环

while循环一般用于不知重复次数但是已知结束条件的循环。

基本格式：

1.循环的初始化
while(2.循环的继续条件){
    3.循环体
    4.循环的步长
}

死循环：将循环条件改为ture。意思是无论进来的是什么值都能进循环。只能通过流程控制语句跳出。

class Test{
    public static void main(String[] args){
        //计算1+2+3+....+99+100
        int sum=0;
        int i=1;        //1.循环初始化
        while(i<=100){  //2.循环的继续条件
            sum=sum+i;  //3.循环体
            i++;        //4.循环的步长
        }
        System.out.println(i);
        System.out.println(sum);
        /*
        死循环：循环一直不出来 CPU在一直执行循环体
        while(true){    //此处必须写条件表达式
            System.out.println("while死循环");
        }
        */
    }
}

 输出 ： 101      5050

• do-while循环

do-while循环和while循环原理基本一致，区别在于条件的先后判断顺序。特点是无论条件是否满足，循环体至少执行一次，而while必须先判断条件，至少执行0次。

do{

                  执行语句；

}while（条件表达式）；

• 流程控制（break 和countinue）

break：终止循环，直接跳出当前循环体。

countinue：跳过本次循环，执行下一次循环。