java流程控制语句

一、顺序结构

代码从主函数开始逐行向下运行；

也是一种宏观的代码运行结构；

二、选择结构

if语句

基本格式

if(条件表达式){

      当条件为true时执行的代码；

}else{

      当条件为false时执行的代码；

}

 

单if形式

if(条件表达式){

     当条件为true时执行的代码;

}

 

 

嵌套if-else形式

if(条件1){

      条件1为true时执行的代码；

      if(条件2){

          条件2为true时执行的代码;

      }else{

          条件2为false时执行的代码;

      }

}else{

      条件1为false时执行的代码；

}

 

 

 

 

if-else-if形式

if(条件1){



}else if(条件2){



}else if(条件3){



}else{



}

 

switch语句

一般在多选情况下用

switch(变量){

    case 值1：

          执行语句1；

          break;

    case 值2：

          执行语句2；

          break;

    case 值3：

          执行语句3；

          break;

    ........

    deafult:

          执行语句n;

          break;

}

 

PS：if它既可以对一个单一的值进行判断，也可以对一个区间的值进行判断，switch只能判断单一的值，switch所要求的变量的数据类型：byte short int char String 枚举。

循环结构

1.主要解决重复性执行的代码

已知重复次数的循环 ： for循环

不知重复次数但是已知结束条件的循环 :  while循环

以上不是一个严格意思上的分类，无论是for还是while，在Java当中都是可以互换的！

 

循环的四要素

1.循环初始化: 指的就是循环从什么时候开始执行

2.循环继续条件:  什么情况循环继续执行/反过来说，循环何时结束

3.循环体 : 就是我们需要被多次循环执行的代码块

4.循环的周期，步长，间距:当前循环和下一次循环之间的变更

下面让我们举个例子；

向前走10步 ： 刚开始的第1步  当前的步数有没有到是10   向前走1步   当前步数与下一个步数的间隔 1 这是一个循环

向前走直到碰墙为止 ：  刚开始的第1步   是否碰墙   向前走1步   当前步数与下一个步数的间隔1   这是一个循环

for循环

for(1循环的初始化 ;  2循环的继续条件 ; 4循环的步长 ){

         3循环体

}

1-2-3-4-2-3-4-2-3-4-2-3-4-2不满足位置；

class Test02{
    public static void main(String[] args){
        /* 
        ********
        1 2 3 4 5 6 7 8
        循环体 *
        */
        /*
        i=1 *
        i=2 *
        ...
        i=7 *
        i=8 *
        i=9 循环结束
         */
        for(int i=1;i<=8;i++){
            System.out.print("*");
        }
        System.out.println("=======================");
        /*
        ********
        ********
        ********
        ********
        循环体 ********
        for(int i=1;i<=4;i++){
             System.out.println("********");
        }
        循环体 *
        */
        //嵌套循环
        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
        循环体 *
        */
        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
            
        要求 * 循环体
        最多出现两个for关键
        只能有一个for嵌套
        */
        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
        */
        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();
        }
    }
}