一. 控制语句

Java 控制语句可以分为 7 种：

控制选择结构语句

• if、if else
• switch

控制循环结构语句

• for
• while
• do while

改变控制语句顺序

• break
• continue

二. If 语句

If 语句属于选择结构，if 语句又被称为分支语句/条件控制语句

1. if 语句的语法结构：四种编写方式

第一种
if（布尔表达式）{
java语句；
java语句；
…
}

第二种
if（布尔表达式）{
java语句；
java语句；
…
} else {
java语句；
java语句；
…
}

第三种
if（布尔表达式）{
java语句
java语句
…
}else if（布尔表达式）{
java语句
java语句
…
}
else if（布尔表达式）{
java语句
java语句
…
}else if（布尔表达式）{
java语句
java语句
…
}…

第四种
if（布尔表达式）{
java语句
java语句
…
}else if（布尔表达式）{
java语句
java语句
…
}
else if（布尔表达式）{
java语句
java语句
…
}else {
java语句
java语句
…
}…

2. 重点 ：对于 java 语句中的 if 语句来说，只要有一个分支执行，整个 if 语句全部结束。

3. 注意：以上的第二种编写方式和第四种编写方式都带有 else 分支，这两种方式可以保证 100%会有分支执行。

4. 所有的控制语句都是可以嵌套使用的，只要合理嵌套就行。

注意：嵌套使用的时候，代码格式要保证完美。【该缩进的时候必须缩进，大部分情况下使用大括号包围的需要缩进】

5. If 语句的分支中只有一条 java 语句的时候，大括号可以不写。

System.out.println();  负责向控制台输出

6. 接收用户键盘的输入语句：

public class KeyInputTest
{
    publid static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in); //第一步，创建键盘扫描器对象
        
        输入字符：
        String UserInputContent = s.next(); 
        //第二步：调用Scanner对象的next方法开始接收用户的键盘输入
        //程序执行到这里会停下来，等待用户的输入
        //当用户输入的时候，并且最终敲回车的时候，输入的信息会自动赋值给userInputContent
        //程序执行到这里，用户输入的信息已经到内存中了，
        System.out.println("您输入了:" + UserInputContent).; //将内存的数据输入到控制台
        
        输入数字
        int num = s.nextInt(); //接收数字 
        System.out.println("您输入的数字是:" + num);
    }
}

正确语句：

public class IfTest01
{
    public static void main(String[] args){
        boolean sex=true;
        if (sex){
            System.out.println("男");
        }else{
            System.out.println("女");
        }
    
        sex=false;
        
        if(sex) System.out.println("男")； else System.out.println("女")；
            
    }
}

错误语句：

public class IfTest02
{
    public static void main(String[] args){
        boolean sex=true;
        if(sex)
            System.out.println("男");
            System.out.println("hehe"); //不加大括号的话只包括第一条语句，第二条语句不是if语句的分支java语句
        else //else缺少if
            System.out.println("女");
        }
}

二. Switch 控制语句

关于 switch 语句：

1. Witch 语句也属于选择结构，也是分支语句

2. Switch 语句的语法结构：

一个比较完整的 switch 语句应该这样编写

switch (int或String类型的字面值或变量){
    case int或String类型的字面值或变量:
        java语句;
        java语句;
        ...
        break;
    case int或String类型的字面值或变量:
        java语句;
        java语句;
        ...
        break;
    case int或String类型的字面值或变量:
        java语句;
        java语句;
        ...
        break;
    default:
        java语句;
        ...
}

3. Switch 语句的执行原理：

switch语句后面小括号当中的“数据”进行一一匹配，匹配成功的分支执行按照自上而下的顺序依次匹配。

4. 匹配成功的分支执行，分支当中最后有“break；”语句的话，整个 switch 语句终止。

5. 匹配成功的分支执行，分支当中没有“break；”语句的话，直接进入下一个分支执行（不进行匹配），这种现象被称为 case 穿透现象。【提供 break；语句可以避免穿透】

case穿透：
int i=10；
switch（i）{
    case 1：
        java语句;
    case 2：
        java语句;
    case 3： 
        java语句;
        break；//输入1,输出的结果是前三条java语句
    case 4:
        java语句;
        System.out.println("Test Code!");
        break;
}

6. 所有分支都没有匹配成功，当有 default 的语句的话，会执行 default 分支当中的程序

7. Switch 后面和 case 后面只能是 int 或者 String 类型的数据，不能是探测其他类型

• 当然 byte，short，char 也可以直接写到 switch 和 case 后面，因为它们可以进行自动类型转换。Byte，short，char 可以自动转换成 int 类型。
• JDK 6 的，switch 和 case 后面只能探测 int 类型。
• JDK 7 之后包括 7 版本在内，引入新特性，switch 关键字和 case 关键字后面可以探测 int 和 string 类型的数据。

8. Case 可以合并：

int i=10；
switch（i）{
    case 1：case 2：case 3： //输入1、2、3输出的结果相同
        java语句;
        break；
    case 4:
        java语句;
        System.out.println("Test Code!");
        break;
}

9. Switch 语句例子

public class SwitchTest01
{
    public static void main(String[] args){
        long a = 10L;
        int b = a; //编译错误
        
        long x = 10L;
        switch(x){} //编译报错，switch语句不能用long
        
        解决编译错误:
        long x = 10L;
        switch((int)x){}
        
        byte b = 10;
        switch(b){} //编译通过

        short s = 10;
        switch(s){} //编译通过
        
        char c = 'A';
        switch(c){} //编译通过
        
        char cc = 12;
        switch(cc){} //编译通过
        
         //编译报错
        //switch(ture){}

        String username = "zhangsan";
        switch(username){}
    }
}

10. Switch 确实可以探测 String 类型，这是 Java 7 的新特性。

简单计算器系统实现：

public class SwitchTest02()
{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("欢迎使用简单计算器系统：");
        System.out.print("请输入第一个数字：");
        int num1 = s.nextInt();
        System.out.print("请输入运算符");
        String operator = s.next();
        System.out.print("请输入第二个数字：");
        int num2 = s.nextInt();

        int result = 0;
        switch(operator){
            case "+" :
                result = sum1 + sum2;
                break;
            case "-" :
                result = sum1 - sum2;
                break;
            case "*" :
                result = sum1 * sum2;
                break;
            case "/" :
                result = sum1 / sum2;
                break;
            case "%" :
                result = sum1 % sum2;
                break;
            default :
                System.out.println("输入运算符号错误");
        }    
        System.out.println("运算结果为："+ num1 + operator + num2 + "=" + result );
    }
}

假设系统给定考生成绩，判断该考生的成绩等级：

有效成绩范围：【0-100】
考试成绩可以有小数
考试成绩和等级之间的对照关系：
【90-100】 A
【80-90】 B
【70-80】 C
【60-70】 D
【0-60】 E
以上需求必须采用switch语句完成，不能采用if
窍门：（int）(成绩 / 10)

public class SwitchTest03()
{
    public static void main(String[] args){
        double score = 数字：
        int grade = (int)(score/10);
        switch(grade){
            case 9:case 10:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
            case 7:
                System.out.println("C");
            case 6:
                System.out.println("D");
            default:
                System.out.println("E");
        }
    }
}

三. 循环结构

在程序当中总有一些需要反复的执行的代码，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数编程语言都是支持循环结构的。将来把需要反复执行的代码片段放到“循环体”中，再联合“计数器”，共同控制这段需要反复执行的代码。

基本上的所有编程语言支持的循环包括三种：

for 循环
while 循环
do…while 循环

四. For 循环

1. 语法结构：

 for (初始化表达式 ; 布尔表达式 ；更新表达式) {
 
循环体:由java语言构成，是需要重复执行的代码片段

 }

2. For 循环的执行过程 / 执行原理？

1.1 初始化表达式、布尔表达式、更新表达式不是必须的！【但是两个分号是必须的】

1.2 初始化表达式最先执行，并且在整个 for 循环当中只执行一次。

1.3 布尔表达式必须是 true/false，不能是其他值。

1.4  for 的执行过程：

1. 先执行初始化表达式，并且该表达式只执行一次。

   
   

2. 判断布尔表达式的结果是 true 还是 false：

   
   
   • 布尔表达式为 true：
   
   
   
   
   1. 执行循环体
   
   
   2. 执行更新表达式
   
   
   3. 判断布尔表达式的结果是 true 还是 false
   
   
   
   
   • 布尔表达式 true:
   
   
   
   
   1. 执行循环体
   
   
   2. 执行更新表达式
   
   
   3. 判断布尔表达式的结果是 true 还是 false
   
   
   • 布尔表达式为 false
     循环结束

循环语句和条件判断语句嵌套使用【for 和 if 的嵌套】

找出1~100所有的奇数

public class ForTest01
{
    public static void main(String[] args){
        第一种方法
        for(int i = 1;i<=100;i+=2){
            System.out.println("奇数-->" + i);
        }
        
        第二种方法
        for(int i=1;i<=100;i++){
            if(i%2 != 0){
                System.out.println(i)
            } 
        }    
    }
}

求1~100所有奇数的和

public class ForTest02
{
    public static void main(String[] args){
        int sum=0;
        for(int i=1;i<=100;i+=2){
            sum+=i;
        }
        System.out.println("sum=" + sum);
    }

3. For 循环也可以嵌套 for 循环

内层循环中的变量名和外层循环中的变量名不能重名

使用 for 循环输出九九乘法表

public class ForTest03
{
    public static void main(String[] args){
        for(int i=1;i<=9；i++){
            for(int j=1;j<=i;j++){
                int  a=i*j;
                System.out.print(i +"*"+j+"="+a );
            }
            System.out.println(); //换行
            //System.out.print("\n");
        }
    }
}

编写 for 循环找出 1~100 中的所有素数

素数：又被称为质数，能够被1和自身整除，不能被其他数字整除的数字称为素数。

public class ForTest04 {

    public static void main(String[] args) {
        for(int i=2;i<=100;i++){
            boolean flag=true; //标记i是否能被其他数整除
            for(int j=2;j<i;j++){ //此刻i只能被1和本身整除，所以应从2~i-1
                if(i%j==0){ 
                    flag=false;  //如果i能被其他数整除，就跳出循环
                    break;
                }
            }
            if (flag)
            System.out.print(i+" ");
        }
    }
}

五. while循环控制语句

1. while循环的语法结构

while（布尔表达式）{
    循环体;
}

2. while循环的执行原理：

判断布尔表达式的结果，如果结果为true就继续执行循环体，直到布尔表达式的结果为false，循环结束。

3. while循环的循环次数：：0~N次

注意：while循环的循环体可能执行次数为0次。

public class WhileTest01 {

    public static void main(String[] args){
        int i = 10;
        int j = 3;
        while(i >j){
            System.out.println("死循环");
        }
        //编译通过
        System.out.println("Hello World!");
        
        //编译错误
        /*
        while(10 > 3){
            System.out.println("死循环");
        }
        */
        
        //编译错误：无法访问语句
        //System.out.println("Hello World!");
        }
    }
}

六. do…while循环控制语句

1. do…while循环的语法结构

do{
    循环体;
}while(布尔表达式);

2. do…while循环的执行原理

先执行循环体，然后判断布尔表示是是否为true，true则执行，false则循环结束。

3. do…while循环的执行次数

do…while循环的循环体代码片段执行次数是：1~N次【至少一次】

4. 使用do …while循环的注意事项

do…while 循环语句最终有一个 “分号” 别丢了。

public class DoWhileTest{
    public static void main(String[] args){
        int i=10;
        do{
            System.out.println(i);
        }while(i>100);  //输出10，先执行在进行判断

        while(i>100){
            System.out.println("i-->"+i);
        } //无输出
    }
}

七. break控制语句

break是java语言当中的关键字，被翻译为“中断/折断”。

break + “;”可以成为一个单独的完整的java语句： break；

break语句使用在switch语句当中，用来终止switch的语句执行。

break语句同样可以使用在循环语句当中，用来终止循环的执行。

break终止哪个循环呢？ break；语句使用在for、while、do…while循环语句当中用来跳出循环，终止循环的执行。因为当程序循环到某个条件时，后续的循环就没必要执行了，在执行也是耗费资源，所以可以终止循环，这样可以提高程序的执行效率。

在默认情况下：break语句终止的是离它最近的循环语句。 当然也可以指定终止某个循环，需要给循环起名，采用这种语法： break 循环名称;

以下以for循环为例解释 break； 语句

public class BreakTest{
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            if(i==5)
            break;
        }
            System.out.println(i); //0 1 2 3 4

        for(int j=0;j<3;j++){
            for(int i=0;i<10;i++){
                if(i==5)
                break;//这里的break语句终止的是内层for循环，因为这个for离它最近。
                //这里的break语句不会影响到外层的for循环
            }
                System.out.println(i); //0 1 2 3 4    0 1 2 3 4      0 1 2 3 4
        }
        
        //给for循环起名
        for1:for(int j=0;j<3;j++){
            for2:for(int i=0;i<10;i++){
                if(i==5){
                    break for1;//终止for1循环
                }
                System.out.println(i); //0 1 2 3 4  
            }
        }
    }
}

八. continue控制语句

1. continue表示：继续/go on/ 下一个

2. continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，主要出现循环语句当中用来控制循环的执行。

3. break和continue的区别：

• break表示循环不执行了。
• continue表示直接进入下一次循环继续执行。

public class ContinueTest{
    public static void main(String[] args){
        for(int i=0;i<10;i++){
            if(i==5)
            break;
        }
            System.out.println(i); //0 1 2 3 4

        for(int i=0;i<10;i++){
            if(i==5)
            continue; //只要这个语句执行，当前本次循环停止，直接进入下一次循环“继续”执行
        }
            System.out.println(i); //0 1 2 3 4 6 7 8 9
    }
}

4. continue也有这样的语法：

continue 循环名称;