第四天总结

流程控制语句

1.顺序结构

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

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

3.2 选择结构

  1.1if语句

基本格式
if(条件表达式){
      当条件为true时执行的代码；
}else{
      当条件为false时执行的代码；
}

单if形式
if(条件表达式){
     当条件为true时执行的代码;
}

该图为单if形式

  1.2嵌套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{

}

 

该图为if-else的嵌套

  2.switch语句

  一般在多选情况下用

格式

switch(变量){

    case 值1：

          执行语句1；

          break;

    case 值2：

          执行语句2；

          break;

    case 值3：

          执行语句3；

          break;

    ........

    deafult:

          执行语句n;

          break;

}

两者有什么区别呢？

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

3.3 循环结构

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

1. 已知重复次数的循环  for循环
2. 不知重复次数但是已知结束条件的循环  while循环

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

循环的四要素

1. 循环初始化

            指的就是循环从什么时候开始执行

1. 循环继续条件

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

1. 循环体

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

1. 循环的周期，步长，间距

            当前循环和下一次循环之间的变更

比如

向前走10步（for）

刚开始的第1步

当前的步数有没有到是10

向前走1步

当前步数与下一个步数的间隔 1

 

向前走直到碰墙为止（while）

刚开始的第1步

是否碰墙

向前走1步

当前步数与下一个步数的间隔1

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