switch语句

switch语句语法及原理

switch语句也是选择语句，也可以叫做分支语句。
语法格式：
switch(值){
case 值1:
java语句;
java语句;
......
break;
case 值2:
java语句;
java语句;
......
break;
case 值3:
java语句;
java语句;
......
break;
default:
java语句;
}
以上是一个完整的switch语句：
其中：break;语句不是必须的。default分支也不是必须的。
switch语句支持的值有：int类型以及String类型。
JDK8之前不支持String类型，只支持int类型。
在JDK8之后，switch语句开始支持字符串String类型。

switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。
switch语句本质上是只支持int和String，但是byte，short，char也可以写入switch小括号里，只不过，byte，short，char，在执行时都会自动类型转换，转换成int类型。
执行原理：拿“值”与“值1”进行比较，如果相同，则执行该分支中的Java语句，然后遇到“break;”语句，switch语句就结束了。如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，以此类推。
注意：如果分支执行了，但是分支最后没有“break”，此时会发生case穿透现象。
case穿透现象就是，值先和值1比较，匹配成功后，运行java语句，没有break的话，会继续执行下一个case里的语句，就不在比较了，直到遇到break。
所有的case都没有匹配成功，那么最后default分支会执行。
case合并

switch(值){
case 1: case 2: case 3:
System.out.println(“啥”)
}

这个“值”无论对应case1还是case2还是case3，都会输出“啥”。

switch案例

业务要求：
1.系统接收一个学生的考试成绩，根据考试成绩纯输出成绩的等级。
2.等级：
优秀：90-100
良好：80-90（不包括90）
中等：70-80（不包括80）
及格：60-70（不包括70）
不及格：0-60（不包括60）
3.要求成绩是一个合法的数字，成绩必须在0-100之间，成绩可能带有小数。
4.必须使用switch语句来完成

public class DengJi{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入学生成绩：");
        double score = s.nextDouble();
        if(score < 0 || score > 100){
            System.out.println("您输入的学生成绩不合法");
            return;
        }
        int grade = (int)(score / 10);
        String str = "不及格";
        switch(grade){
        case 10: case 9:
            str = "优秀";
            break;
        case 8:
            str = "良好";
            break;
        case 7:
            str = "中等";
            break;
        case 6:
            str = "及格";
            break;
        }
        System.out.println("该学生的成绩等级是：" + str);
    }
}

等级.png

循环语句

在现实世界当中，有很多事情都是需要反复/重读的去做。对应到程序当中，如果有一块代码需要重复执行，此时为了减少代码量，我们使用循环语句。
相同的代码，重读出现的时候，可以使用循环语句。

for循环语句

语法机制：
for(初始表达式 ;条件表达式;更新表达式){
循环体;//循环体由java语句构成
}
注意：
1.初始化表达式最先执行，并且在整个循环中只执行一次。
2.条件表达式结果必须是一个布尔类型，也就是true或false。
执行原理：
初始化表达式最先执行，并且初始化表达式只执行一次，然后执行条件表达式，如果条件表达式为true，执行循环体，然后执行更新表达式，然后执行条件表达式，如果条件表达式为true，继续执行循环体，再执行更新表达式，以此类推，直到条件表达式为false，结束循环。
更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新某个标量的值，这样条件表达式的结果才有可能从true变成false，从而终止for循环的执行，如果缺失更新表达式很有可能会导致死循环。

for死循环以及常见的简单for循环

初始表达式、条件表达式、更新表达式，其实都不是必须的。

for(;;){
  System.out.println("死循环");
}

最常见的for循环

//循环10次，输出0-9
//对于这个for循环，其中int i= 0;最先执行，并且只执行一次。
//而且i变量属于for 循环的局部变量，for循环结束后，i的内存就释放了。
//这个i变量只能再for循环中使用。
//这个i变量属于for循环域。
//在main方法中没有办法直接使用。
for(int i = 0;i < 10;i++){
  System.out.println("i = " + i);
}

for循环变形

for(int i = 0;i <= 10;i++){
  System.out.println("i = " + i);//1,2,3,4,5,6,7,8,9,10
}

以下这样也是可以的。结果与上个代码相同

for(int i = 0;i <= 10;){
  System.out.println("i = " + i);
  i++;
}

变形

for(int i = 0;i <= 10;){
  i++;
  System.out.println("i = " + i);//2,3,4,5,6,7,8,9,10,11
}

其他形式

for(int i = 10;i  > 0;i--){
  System.out.println("i = " + i);//10,9,8,7,6,5,4,3,2,1
}

for(int i = 0;i < 10;i += 2){
  System.out.println("i = " + i);// 0,2,4,6,8
}

//1对3 的余数，结果还是1
for(int i = 100;i > 0;i %= 3){
  System.out.println("i = " + i);//100,1,1,1,1,......死循环
}

for循环案例:求1~100奇数和

使用for循环，实现1~100所有奇数求和
第一种方案：
思路：先找出1~100所有的的奇数，然后再考虑求和的事儿。
第一步：先从1取到100，一个数字一个数字取出来。
第二步：既然可以得到每一个数字，那么我们进一步判断这个数字是否为奇数。
奇数对2取余，结果都是1

public class Test1{
    public static void main(String[] args){
        int sum = 0;//初始值给0
        for(int i = 1; i <=100; i++){
            if(i % 2 == 1){//i为奇数
                sum += i;//累加（sum = sum + i;）
            }
        }
        //for循环结束之后，输出的sum结果就是最终的结果。
        System.out.println("1到100所有奇数求和结果为：" + sum);//2500
    }
}

第二种方案：
这种方案效率高，因为循环次数比较少。

public class Test1{
    public static void main(String[] args){
        int sum = 0;//初始值给0
        for(int i = 1; i < 100; i += 2){
        //这样写可以保证每一次取出的值都是奇数。不需要判断
            sum += i;
        }
        System.out.println("1到100所有奇数求和结果为：" + sum);
    }
}

for循环嵌套

所有合法的“控制语句”都可以嵌套使用。
不要因为for循环中嵌套了一个for循环，就感觉这个程序比较特殊，实际上大家可以，在分析外层for循环的时候把里面的for循环就当作一段普通的java语句/代码。

public class Test1{
    public static void main(String[] args){
        for(int k = 0; k < 2 ; k++ ){
            for(int i = 0; i < 10; i++ ){
                System.out.println("k = " + k);//10个0 10个1
                System.out.println("i = " + i);//两次0-9
            }
        }
    }
}

for嵌套实现九九乘法表

九九乘法表
11=1
12=2 22=4
13=3 23=6 33=9
......
19=9 29=18 ..................... 9*9=81
特点：共9行。第1行1个，第2行2个，第n行n个。

public class Test1{
    public static void main(String[] args){
        for(int i = 1; i<=9 ; i++ ){//i是行号1-9
                        //负责输出一行的。（内部for循环负责将一行上的全部输出）
            for(int j = 1; j<=i ; j++ ){
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
        System.out.println();//换行
        }
    }
}

九九乘法表.png

while循环的语法机制和执行原理

语法机制：
while(布尔表达式){
循环体;
}
执行原理：判断布尔表达式的结果，如果为true就执行循环体，循环体结束之后，再次判断布尔表达式的结果，如果还是true，继续执行循环体，直到布尔表达式结果为false，while循环结束。
while循环的循环次数有可能是0次。while(false)的时候，就是执行了0次。所以，while循环的循环次数是：0~n次。
while(true)这样就是死循环了。
本质上while循环和for循环原理是相同的。

for(初始化表达式;布尔表达式;更新表达式){
  循环体;
}

初始化表达式；
while(布尔表达式){
  循环体;
  更新表达式;
}

for和while完全可以互换，只不过就是语法格式不一样。

do while的语法机制和执行原理

语法机制：
do{
循环体;
}while(布尔表达式);
注意：do ..while循环最后的时候不要漏掉“分号”。
执行原理：先执行循环体当中的代码，执行一次循环体之后，判断布尔表达式的结果，如果为true，则继续执行循环体，如果为false循环结束。
对于do..while循环来说，循环体至少执行1次。循环体的执行次数是：1~n次。
对于while循环来说，循环体执行次数是：0~n次。
do..while循环的特点是，先执行循环体再判断条件

break语句

break;这个语句比较特殊，特殊在break语句是一个单词成为一个完整的jaba语句。
另外：continue也是这样，它俩都是一个单词成为一条语句。
break 翻译为折断、弄断。
break可以用在switch语句当中，用来终止switch语句的执行，防止case穿透现象。
break也可以用在循环语句（for、while、do..while..）当中，用来终止循环的执行。
break;语句会让离它最近的循环终止结束掉。
break；语句的执行并不会让整个方法结束。break;语句主要是用来终止离它最近的哪个循环语句。
以for循环为例学习break语句。

public class Test1{
    public static void main(String[] args){
        for(int i = 1; i < 10 ; i++ ){
            if(i == 5){
            //break终止的不是if，不是针对if的，而是针对离它最近的循环。
            break;
            }
            System.out.println("i = " + i);//0 1 2 3 4
        }
    }
}

public class Test1{
    public static void main(String[] args){
        //外层for循环两次
        for(int k = 0; k < 2 ; k++ ){//外层for
            for(int i = 1; i < 10 ; i++ ){//内层for
                if(i == 5){
                break;//终止离它最近的for
                }
                System.out.println("i = " + i);
            }   
        
        }
    }
}

那么如果想要终止外层for该怎么办呢？
以下内容开发很少用，不要紧张。这种语法很少用，了解以下即可。
第一步：给循环起一个名字，例如：a:for、b:for
第二步：break a;就中止了。

public class Test1{
    public static void main(String[] args){
        a:for(int k = 0; k < 2 ; k++ ){
            b:for(int i = 1; i < 10 ; i++ ){
                if(i == 5){
                break a;//终止指定循环
                }
                System.out.println("i = " + i);
            }   
        
        }
    }
}

continue语句

continue翻译为：继续。
continue语句和break语句要对比着学习。
continue语句的作用是：终止当前“本次”循环，直接进入下一次循环继续执行。
continue语句后面也是可以指定循环的。

public class Test1{
    public static void main(String[] args){
        for(int i = 1; i < 10 ; i++ ){
            if(i == 5){
            continue;
            }
            System.out.println("i = " + i);//0 1 2 3 4 6 7 8 9
        }
    }
}

break和continue的区别：

面试官接完电话走了，这就是break.png
面试3号答不上来，直接叫下一位，这就是cocontinue.png