JavaSE--控制语句

一、控制语句

1、控制语句分类

• 顺序结构
  • 按照顺序来执行程序
• 分支结构/选择语句
  • 单分支if、多分支switch
• 循环结构
  • for、while、do while

2、分支结构

  1）单分支 if

单分支 if
    语法格式：
    第一种写法：
        if(布尔表达式){
            java语句;
        }
        这里一个大括号叫做一个分支
    if执行原理：如果布尔表达式的结果为true，则执行大括号中的程序，否则不执行
    第二种写法：
        if(布尔表达式){// 分支1
            java语句;
        }else{        // 分支2
            java语句;
        }
    执行原理：如果布尔表达式的结果为true，则执行分支1，否则执行分支2
    第三种写法：
        if(布尔表达式){// 分支1
            java语句;
        }else if(布尔表达式){// 分支2
            java语句;
        }else if(布尔表达式){
            java;
        }......
    第四种种写法：
        if(布尔表达式){// 分支1
            java语句;
        }else if(布尔表达式){// 分支2
            java语句;
        }else if(布尔表达式){
            java;
        }else{
        }
    注意：对于if语句来说，只能有1个分支执行，不可能有两个或更多个分支执行
    
// 分支中只有一条java语句的时候{}可以省略
if(flag) System.out.print("1"); else System.out.print("2");
    
// 控制语句与控制语句之间可以嵌套,循环与控制之间也可以嵌套
if(布尔表达式){
    if(布尔表达式){
        while(){}
    }else{
        for(){}
    }
}else{
    java语句;
}

  2）多分支 switch

多分支 switch
语法格式：
    switch(值){
        case 值1:
            java语句;
            java语句;
            break;
        case 值2:
            java语句;
            java语句;
            break;
        case 值3:
            java语句;
            java语句;
            break;
        default:
            java;
    }
    其中：break;和deafult:分支不是必须的
    “值”：只支持int、String类型（jdk8之前不支持String），但是传入byte、short、char时会自动进行类型转换
    switch语句中值与值1 值2 比较的时候 内部使用 ==
执行原理：
    拿“值”与“值1”比较，如果相同，执行分支中的java语句，然后break语句结束
    如果与“值1”不相等，会与“值2”比较，依次
    注意：如果没有break;语句会发生case穿透，一直顺序执行语句直到遇见break
    
short s = 100;
switch(s){
}
char c = 'a';
switch(c){
}
switch("abc"){
}

3、循环结构

  1）for循环

for循环
// 语法格式：
for(初始化表达式;布尔表达式;更新表达式){
    循环体;
}
    初始化表达式最先执行，并且只执行一次
    条件表达式结果必须是一个布尔类型
// 执行原理：
    先执行初始化表达式，然后判断条件表达式的结果，结果为true，执行循环体
    循环结束后执行更新表达式
    更新完之后，再次判断条件表达式，如果还是true，继续执行循环体
    只有当条件表达式为false时，结束循环
// 更新表达式作用：控制循环次数，更新表达式会更新某个变量的值，这样条件表达的结果才会变false
 
public class ForTest01{
    public static void main(String[] args){
        // 这是一个死循环
        for(;;){
            System.out.println("死循环")
        }
        // 最常见的
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
        int k = 0;// 域扩大了
        for(;k<10;k++){
            System.out.println(k);
        }
        // 变形
        for(int i=1;i<=10;i++){
            System.out.println(i);
        }
        // 变形
        for(int i=1;i<=10;){
            System.out.println(i);
            i++;
        }
        // 变形
        for(int i=1;i<=10;){
            i++;
            System.out.println(i);
        }
    }
}

  2）for循环变形

// for其他形式
public class ForTest02{
    public static void main(String[] args){
        // for的其他形式
        for(int i = 10;i > 0;i--){
            System.out.println(i);// 10 9 8 7 6 5 ...1
        }
        // 变形
        for(int i = 0;i < 10;i += 2){
            System.out.println(i);// 0 2 4 6 8
        }
        // 变形
        for(int i = 100;i > 0;i %= 3){// 1 % 3 = 0 ...1
            System.out.println(i);// 100 1 1 1 1...死循环
        }
    }
}

  3）for循环嵌套

// for循环嵌套
public class ForTest03{
    public static void main(String[] args){
        for(int i = 0;i < 10;i++){
            for(int k = 0;i < 10;i++){
                System.out.println(i+";"+k);
            }
        }
        // 定义在外面
        int k = 0;
        for(int i = 0;i < 10;i++){
            for(;k < 10;k++){// 只输出一边，第二次的时候k变成10，不符合条件
                System.out.println(i+";"+k);
            }
        }
    }
}

  4）while循环

while循环
while(布尔表达式){
    循环体;
}
 
初始化表达式;
while(布尔表达式){
    循环体;
    更新表达式;
}
执行原理：
    判断布尔表达式的结果，结果为true执行循环体，
    再次判断布尔表达式，为true继续执行循环体，为false，结束循环
public class WhileTest01{
    public static void main(String[] args){
        // 死循环
        while(true){
            System.out.println("死循环");
        }
        // 
        int i = 0;
        while(i < 10){
            System.out.println(i);
            i ++;
        }
    }
}

  5）do...while循环

do..while循环
do{
    循环体;
}while(布尔表达式);
执行原理：
    先执行循环体的代码，再判断布尔表达式的结果，结果为true再次执行循环体，
    再次判断布尔表达式，为true继续执行循环体，为false，结束循环
    循环体至少执行一次
public class DoWhileTest01{
    public static void main(String[] args){
        int i = 0;
        do{
            System.out.println(i);
            // System.out.println(i++);
            i ++;
        }while(i<10);
    }
}

 4、转向语句

• break;
• continue;
• return;

  1）break语句

break;语句
break翻译为折断 弄断
break语句作用：
    放在switch语句中，终止switch，防止case穿透
    放在循环语句中，终止循环
public class BreakTest{
    public static void main(String[] args){
        for (int i = 0;i < 10;i++){
            if(i==5){
                // 会让离他最近的循环终止结束
                break;
            }
            System.out.println(i);
        }
    }
}

  2）continue语句

continue;语句
continue翻译为继续 持续
continue语句作用：
    
public class ContinueTest{
    public static void main(String[] args){
        for (int i = 0;i < 10;i++){
            if(i==5){
                // 当前本次循环结束，这次循环后的代码也不执行，直接跳到下次循环，
                continue;
            }
            System.out.println(i);
        }
    }
}

  3）return语句

  在之后会说