控制语句

1 怎么接收用户键盘输入？

    java.util.Scanner s = new java.util.Scanner(System.in);

    // 接收整数

    int i = s.nextInt();

    // 接收字符串

    String str = s.next();

 

2 控制语句

    2.1 控制语句的出现可以让我们的程序具有逻辑性，条理性，可以使用控制语句来实现一个业务了。

 

    2.2 控制语句包括几类？

        3类：

        选择语句

        循环语句

        转向语句

 

    2.3 选择语句也可以叫做分支语句

        if语句

        switch语句

 

    2.4 循环语句，主要循环反复的去执行某段特定的代码块。

        for循环

        while循环

        do..while..循环

    

        什么是循环语句，为什么要是用这种语句?

            因为在现实世界当中，有很多事情都需要反复/重复的去做。

            对应到程序当中，如果有一块代码需要重复执行，此时为了减少代码量，我们使用循环语句。

            

    2.5 转向语句

        break

        continue

        return(目前先不需要学习，后面讲方法的时候会使用，到时候再说)

 

3 选择语句/分支语句 if

 

 

if选择语句：

---------------------------------------------------------↓ if选择语句 ↓----------------------------------------------------------

/*
    if语句的语法结构记忆运行原理？
        if语句是分支语句，也可以叫做条件语句。
        if语句的语法格式：
            第一种写法：
                if(不是随便写的，必须是布尔表达式){
                    java语句;
                }
            这里的大括号{}叫做一个分支。
            if 这个单词翻译为如果，所以又叫做条件语句。
            该语法的执行原理是：
                如果布尔表达式的结果是true，则执行大括号中的程序，否则大括号中代码不执行。

            第二种写法：
                if(布尔表达式){
                    java语句;
                }else{
                    java语句;
                }
                执行原理：如果布尔表达式的结果是true，则执行分支1，分支2不执行。
                如果布尔表达式的结果是false，分支1不执行，执行分支2
                以上的这个语句可以保证一定会有一个分支执行。
                else表示其他
                        
            第三种写法：
                if(布尔表达式1){
                    java语句;
                }else if(布尔表达式2){
                    java语句;
                }else if(布尔表达式3){
                    java语句;
                }else if(布尔表达式4){
                    java语句;
                }......
                
                以上if语句的执行原理？
                    先判断布尔表达式1，如果布尔表示1为true，则执行分支1，然后if语句结束了。
                    当布尔表达式1结果是false，那么会继续判断布尔表达式2的结果，如果布尔表达式的结果是true，则执行分支2，整个if就结束了。
                    从上往下以此判断，主要看第一个true发生在哪个分支上。
                    第一个true对应的分支执行，只要一个分支执行，整个if结束。
                    
            第四种写法：
                if(布尔表达式1){
                    java语句;
                }else if(布尔表达式2){
                    java语句;
                }else if(布尔表达式3){
                    java语句;
                }else if(布尔表达式4){
                    java语句;
                }else{
                    java语句;
                }
                
                以上条件没有一个成立的，则执行else。
                
        注意：1 对于if语句来说，在任何情况下只能有1个分支执行，不可能存在2个或者更多个分支执行。
                        if语句中只要有1分分支执行了，整个if语句就结束了（对于1个完成的if语句来说的）。
                    
                    2 以上4种语法机制中，凡是带有else分支的，一定可以保证会有一个分支执行。
                        以上4种当中，第一种和第三种没有else分支，这样的语句可能会导致最后一个分支都不执行。其中第二种和第四种肯定会有1个分支执行，
                        因为他们有else。
                        
                    3 当分支当中java语句只有一条的时候，大括号可以省略不写，但为了可读性，最好不好省略。
                        有的程序员在编写代码的时候可能会故意将大括号省略，你需要可以看懂。
                        
                    4 控制语句和控制语句之间是可以嵌套的。但是嵌套的时候大家最好一个语句一个语句进行分析，不要冗杂在一起分析。
                        小窍门：分析外面if语句的时候，里面的这个if语句可以看做是普通的一堆java代码。
            
*/
public class IfTest01{
    public static void main(String[] args){
        
        //定义一个布尔类型的变量，表示性别。
        boolean sex = false;
        
        // 业务：当sex为true时表示男，为false的时候表示女。
        /*
        if (sex == true) { //是关系运算符，不是赋值运算符， == 是用来判断是否相等的  不具备赋值作用
            System.out.println('男');    
        }else{
            System.out.println('女');    
        }
        */
        // 改良代码。
        if (sex) {
            System.out.println('男');    
        }else{
            System.out.println('女');    
        }
        
        // 可以在进一步改良
        // 可以使用三目运算符
        sex = true;
        System.out.println(sex?'男':'女');
        
        // 代码可以这样写吗？
        // () 小括号当中最终取的值是sex变量的值
        // 而sex是布尔类型，所以这个可以通过。
        // 这种写法太ne了，不要这么写，这样你会让else分支不在有价值。
        /*sex = false;
        if (sex = true) {
            System.out.println('男');    
        }else{
            // 虽然这种语法可以，但是会导致else分支永远不能执行。
            System.out.println('女');    
        }*/
        
        // 省略了大括号的写法
        // 当分支中有一条java语句的话，大括号可以省略。
        if (sex)
            System.out.println('男');    
        else
            System.out.println('女');    
        
        // 判断一下程序会出现问题吗？会出什么问题？第几行代码会报错？
        // IfTest01.java:121: 错误: 有 'if', 但是没有 'else'
        if (sex)
            System.out.println('男');    
            System.out.println("Hello World");    
        /*else //这一行编译报错，因为else缺少if
            System.out.println('女');*/
        
    }
}

/*
    业务要求：
        1 从键盘上接收一个人的年龄。
        2 年两要求为[0-150]，其他值表示非法，需要提示非法信息。
        3 根据人的年龄动态的判断这个人属于生命的哪个阶段？
            [0-5] 婴幼儿
            [6-10] 少儿
            [11-18] 少年
            [19-35] 青年
            [36-55] 中年
            [56-150] 老年
        4 请使用if语句完成以上的业务逻辑
*/
public class IfTest02{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入年龄：");
        int age = s.nextInt();
        //System.out.println("测试以下，您输入的年龄是：" + age);
        /*对于初学者来说可能代码会写成这样，这是正常的。
         代码的经验需要一步步的积累，慢慢的代码就会越来越漂亮了
         需要时间，需要积累代码经验。最好的代码是：最少的代码量，最高的效率*/
        /*if(age >= 0 && age <= 5){
            System.out.println("这一个婴幼儿的年龄");
        } else if (age >= 6 && age <= 10) {
            System.out.println("这一个少儿的年龄");
        } else if (age >= 11 && age <= 18) {
            System.out.println("这一个少年的年龄");
        } else if (age >= 19 && age <= 35) {
            System.out.println("这一个青年的年龄");
        } else if (age >= 36 && age <= 55) {
            System.out.println("这一个中年的年龄");
        } else if (age >= 59 && age <= 150) {
            System.out.println("这一个老年的年龄");
        } else {
            System.out.println("这一个非法的年龄");
        }*/
        
        // 嵌套的if else语句
        /*if(age < 0 || age > 150){
            System.out.println("对不起，年龄值不合法");
        } else {
            if (age <= 5){
                System.out.println("婴幼儿");
            }else if(age <= 10){
                System.out.println("少儿");
            }else if(age <= 10){
                System.out.println("少年");
            }else if(age <= 18){
                System.out.println("青年");
            }else if(age <= 35){
                System.out.println("中年");
            }else{
                System.out.println("老年");
            }
        }*/
        
        String str = "老年"; // 字符串变量默认值是"老年"
        
        if(age < 0 || age > 150){
            System.out.println("这一个非法的年龄");
            // 既然不合法，你就别让程序继续往下执行了，怎么终止程序呢？
            return;
        } else if(age <= 5){
            System.out.println("这一个婴儿的年龄");
        } else if (age <= 10) {
            System.out.println("这一个少儿的年龄");
        } else if (age <= 18) {
            System.out.println("这一个少年的年龄");
        } else if (age <= 35) {
            System.out.println("这一个青年的年龄");
        } else if (age <= 55) {
            System.out.println("这一个中年的年龄");
        } else if (age <= 150) {
            System.out.println("这一个老年的年龄");
        }
        System.out.println(str);
    }    
}

/*
    题目：
        1 系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。
        
        2 等级：
            优 : [90~100]
            良 : [80~90]
            中 : [70~80]
            及格 : [60~70]
            不及格 : [0~60]
        
        3 要求乘积是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。
*/
public class IfTest03{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        //String Achievement = s.next();
        //double d = Double.parseDouble(Achievement);
        //System.out.print("这个学生的成绩是：" + Achievement);
        
        double Achievement = s.nextDouble();
        
        if(Achievement < 0 || Achievement > 100){
            System.out.println("您输入的成绩为非法成绩");
        }else if(Achievement < 60){
            System.out.println("您输入的成绩为不及格");
        }else if(Achievement < 70){
            System.out.println("您输入的成绩为及格");
        }else if(Achievement < 80){
            System.out.println("您输入的成绩为中");
        }else if(Achievement < 90){
            System.out.println("您输入的成绩为良");
        }else{
            System.out.println("您输入的成绩为优");
        }
    }    
}

/*
    题目：
        业务：
            从键盘上接收天气的信息：
                1表示：雨天
                0表示：晴天
            同时从键盘上接收性别的信息：
                1表示：男
                0表示：女
            业务要求：
                当天气是雨天的时候：
                    男的：打一把大黑伞
                    女的：打一把小花伞
                当天其实晴天的时候：
                    男的：直接走起，出去玩耍
                    女的：擦点防晒霜，出去玩耍
                
                需要使用if语句以及嵌套的方式展现这个业务。
                
                可以再程序的开始，接收两个数据，一个数据是天气，一个数据是性别。
                然后将这两个数据保存到变量中。
*/
public class IfTest04{
    public static void main(String[] args){
        java.util.Scanner s = new java.util.Scanner(System.in);
        
        System.out.print("请输入对应的天气：");
        int weather = s.nextInt();
        
        System.out.print("请输入对应的性别：");
        int sex = s.nextInt();
        
        if(weather == 0){
            if(sex == 1){
                System.out.println("晴天了、男孩直接走起，出去玩耍");
            }else if(sex == 0){
                System.out.println("晴天了、女孩擦点防晒霜，出去玩耍");
            }else{
                System.out.println("您输入的性别有误，请输入正确的性别");
            }
        }else if(weather == 1){
            if(sex == 1){
                System.out.println("下雨啦、男孩打了一把大黑伞");
            }else if(sex == 0){
                System.out.println("下雨了、女孩打了一把小花伞");
            }else{
                System.out.println("您输入的性别有误，请输入正确的性别");
            }
        }else{
            System.out.println("您输入的天气有误，请输入正确的天气。");
        }
    }    
}

switch选择语句：

---------------------------------------------------------↓ switch选择语句 ↓----------------------------------------------------------

 

/*
    switch语句：
        1 switch语句也是选择语句，也可以叫做分支语句。
        2 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类型
                但一定要注意JDK的版本，在jdk8之前不支持String类型，只支持int。
                在jdk8之后，switch语句开始支持字符串String类型。
                
                switch语句本质上只支持int和String，但是byte、short、char也可以使用在switch语句当中，
                因为byte、short、char可以进行自动类型转换。
                
                switch语句中“值”与“值1”、“值2”比较的时候，会使用“==”进行比较。
            
        3 switch语句的执行原理
            拿“值”与“值1”进行比较，如果相同，则执行该分支中的Java语句，
            然后遇到“break;”语句，switch语句就结束了。
            如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，则执行该分支中的java语句，然后遇到break;语句，switch结束。
            
            注意：如果分支执行了，但是分支最后没有“break;”，那么会发生case穿透现象。
            
            所有的case都没有匹配成功，那么default分支会执行。
*/

public class SwitchTest01{
    public static void main(String[] args){
        
        // 分析这个程序是否能够编译通过？
        // switch只支持int和String类型。
        // 错误: 不兼容的类型: 从long转换到int可能会有损失
        /*long x = 100L;
        switch(x){
            
        }*/
        
        // 以下这些都是可以的，因为他可以接收String和int类型。
        /*long x = (int)100L;
        switch(x){
            
        }*/
        
        /*byte b = 100;
        switch(b){
                
        }*/
        
        /*short c = 100;
        switch(c){
                
        }*/
        
        /*char d = 'a';
            // 相当于 int i = c;
        switch(d){ //实际上这里相当于97
                
        }
        
        // switch支持String字符串类型（jdk1.8版本以上支持）。
        /*switch("abc"){
        
        }*/
        
        // 写一个完整的switch语句
        // 接收键盘输入，根据输入的数字来判断星期几。
        // 0 星期天
        // 1 星期一
        // ......
        
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.print("请输入您要输入的数字：");
        int i = s.nextInt();
        
        /*switch(i){
            case 0:
                System.out.println("星期天");
                break;
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            default:
                System.out.println("您输入的天气数字有误！请重新输入！");
        }*/
        
        // case穿透现象
        /*switch(i){
            case 0:
                System.out.println("星期天");
                break;
            case 1:
                System.out.println("星期一");
                // break; // 这里注释掉了哦  没有了break; 所以他就回继续向下执行，直到有break;之后，才会停下来。
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            default:
                System.out.println("您输入的天气数字有误！请重新输入！");
        }*/
        
        // 关于default语句，当所有的case都没有匹配上的时候，执行default语句。
        /*switch(i){
            case 0:
                System.out.println("星期天");
                break;
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            default:
                System.out.println("您输入的天气数字有误！请重新输入！");*/
        
        // 关于case合并的问题
        switch(i){
            case 0: case 1: case 2:
                System.out.println("星期天");
                break;
            case 3: case 4: case 5:
                System.out.println("星期三");
                break;
            case 6:
                System.out.println("星期六");
                break;
            default:
                System.out.println("您输入的天气数字有误！请重新输入！");
        }
    }
}

/*
    题目：
        1 系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。
        
        2 等级：
            优 : [90~100]
            良 : [80~90]
            中 : [70~80]
            及格 : [60~70]
            不及格 : [0~60]
        
        3 要求乘积是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。
        
        必须使用switch语句来完成，你该怎么办？
*/
public class SwitchTest02{
    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);// 假设说这个学生的成绩是95 那么95 / 10 = 9.5 强转成int是9
        switch(grade){
            case 9: case 10:
                System.out.println("该学生的成绩是优");
                break;
            case 8:
                System.out.println("该学生的成绩是良");
                break;
            case 7:
                System.out.println("该学生的成绩是中");
                break;
            case 6:
                System.out.println("该学生的成绩是及格");
                break;
            case 0: case 1: case 2: case 3: case 4: case 5:
                System.out.println("该学生的成绩是不及格");
                break;
            default:
                System.out.println("您输入的学生成绩不合法!再见！");
        }
    }
}

for循环语句：

---------------------------------------------------------↓ for循环语句 ↓----------------------------------------------------------

/*
    为什么要使用循环？
    循环语句的出现就是为了解决代码的复用性。
    
*/
public class ForTset01{
    public static void main(String[] args){
        // 要求在控制台上输出100个100
        // 什么时候可以考虑使用循环呢？相同的代码重复出现的时候，可以使用循环语句。
        int number = 100;
        for(int i = 0; i < 100; i++){
            System.out.println(number);
        }
    }
}

/*
    1 for循环的语法机制以及运行原理？
        语法机制：
            for(初始化表达式;条件表达式;更新表达式){
                循环体; // 循环体由java语句构成
                java语句;
                java语句;
                java语句;
                java语句;
                java语句;
                ....
            }
            
            注意：
                第一：初始化表达式祖先执行，并且在整个循环中只只执行一次。
                第二：条件表达式结果必须是一个布尔类型，也就是说true或者false。
            
            执行原理：
                先执行初始化表达式，并且初始化表达式只执行1次。
                然后判断条件表达式的结果，如果条件表达式结果为true，则执行循环体。
                循环体结束之后，执行更新表达式。
                更新完之后，在判断条件表达式结果，如果还是true，继续执行循环体。
                直到更新表达式之行结束之后，在判断条件时，条件为false，for循环终止。
                
            更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新某个变量的值，
            这样条件表达式的结果才有可能从true变成false、从而终止for循环的执行。如果缺失更新表达式，很有可能变成死循环。
*/
public class ForTest02{
    public static void main(String[] args){
        // 最简练的for循环怎么写？
        // 初始化表达式、条件表达式、更新表达式其实都不是必须的
        
        /* for(;;){
            System.out.println("死循环");
        }*/
        
        // 最常见的for循环
        // 循环10次，输出0-9
        /*
            i = 0
            i = 1
            i = 2
            i = 3
            i = 4
            i = 5
            i = 6
            i = 7
            i = 8
            i = 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);
        }*/
        
        // i变量的作用域就扩大了。
        int i = 0;
        for( ; i < 10 ; i++){
            System.out.println("i --> " + i);
        }
        
        System.out.println("这里的i可以访问吗？ i = " + i);// 10
        
        // 变形
        for(int k = 1 ; k <= 10 ; k++){
            System.out.println("k --> " + k); // 1 2 3 ... 10
        }
        
        // 变形
        for(int k = 1 ; k <= 10 ;){
            System.out.println("k --> " + k); // 1 2 3 ... 10
             k++;
        }
        
        // 变形
        for(int k = 1 ; k <= 10 ;){
            k++;
            System.out.println("value --> " + k); // 2 3 4 ... 10  11
        }
    }
}

public class ForTest03{
    public static void main(String[] args){
        // for的其他形式。
        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("value1 = " + i);
        }
        
        // 死循环
        // 注意： 1对3 求余数， 结果还是1
        /*for(int i = 100; i > 0 ; i %= 3){
            System.out.println("value2 = " + i);
        }*/
        
        
    }
}

/*
    使用for循环实现1~100所有奇数求和
    至少给出两种解决方案
*/
// 我自己写出来的方案
public class ForTest04{
    public static void main(String[] args){
        int k = 0;
        for(int i = 1; i <= 100; i += 2){
            k = i + k;
        }
        
        System.out.println("1~100的奇数之和是：" + k);
        
        /*
            第一种方案
            思路：先找出1~100所有的奇数，然后在考虑求和的事儿。
            第一步：先从1取到100，一个数字一个数字的取出来。
            第二步：既然可以得到每一个数字，那么我们进一步判断这个数字是否为奇数，
            奇数对2求余数，结果都是1
        */
        int sum = 0;
        for(int i = 1; i <= 100; i++){
            // int sum = 0; //不能在这个循环体中声明，这样会导致“计算器归0”
            // for循环中嵌套了if语句。
            if(i % 2 ==1){ // i为奇数的条件
                sum += i;
            }
        }
        
        System.out.println("1~100所有的奇数求和结果是：" + sum);
        
    }
}

/*
    1 所有合法的控制语句都可以嵌套使用
    2 for循环嵌套一个for循环执行原理是什么？
        提示一下：大家不要因为for循环中嵌套了一个for循环就感觉这个程序比较特殊，实际上，大家可以这样看待：
        for(){
            //在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码。
            for(){
            
            }
        }
*/
public class ForTest05{
    public static void main(String[] args){
        
        //单层for循环
        for(int i = 0; i < 10; i++){
            System.out.println("i = " + i);
        }
        
        for(int k = 0; k < 2; k++){//循环两次
            System.out.println("k = " + k);
        }
        
        /*
        输出结果
        k ---> = 0
        i---> = 0
        i---> = 1
        i---> = 2
        i---> = 3
        i---> = 4
        i---> = 5
        i---> = 6
        i---> = 7
        i---> = 8
        i---> = 9
        k ---> = 1
        i---> = 0
        i---> = 1
        i---> = 2
        i---> = 3
        i---> = 4
        i---> = 5
        i---> = 6
        i---> = 7
        i---> = 8
        i---> = 9
        */
        /*for(int k = 0; k < 2; k++){//循环两次
            System.out.println("k ---> = " + k);
            // 外面循环一次，他就循环10次(因为外面的for控制里面的for)    因为外面循环了两次，所以他就循环两个10次
            for(int i = 0; i < 10; i++){//循环10次   
                System.out.println("i---> = " + i);
            }
        }/*
        
        /*
        // 第一遍
        for(int i = 0; i < 10; i++){//循环10次    所以他就循环两个10次
                System.out.println("i == > " + i);
        }
        
        // 第二遍
        for(int i = 0; i < 10; i++){//循环10次    所以他就循环两个10次
                System.out.println("i == > " + i);
        }
        */
        int i = 0;
        
        for(int k = 0; k < 2; k++){
            for(; i < 10; i++){
                System.out.println("k ---> = " + k);
                System.out.println("value ---> = " + i);
            }
        }
        
    }
}

/*
    利用for循环实现99乘法表
*/
public class ForTest06{
    public static void main(String[] args){
        
        for(int i = 1 ; i <= 9 ; i++){
            for(int k = 1 ; k <= i ; k ++){
                System.out.print(k + "*" + i + "=" + i * k + " ");
            }
            System.out.println();
        }
        
    }    
}

public class ForTest07{
    public static void main(String[] args) {
        //冒泡排序算法
        int[] numbers=new int[]{1,5,8,2,3,9,4};
        int i,j;
        for(i=0;i<numbers.length-1;i++){
            for(j=0;j<numbers.length-1-i;j++){
                if(numbers[j]>numbers[j+1]){
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}

while循环语句：

---------------------------------------------------------↓ while循环语句 ↓----------------------------------------------------------

 

/*
    while循环：
        1 while循环的语法机制以及执行原理
            语法机制：
                while(布尔表达式){
                    循环体;
                }
                
                执行原理：
                    判断布尔表达式的结果，如果为true就执行循环体，循环体结束之后，再次判断布尔表达式的结果，
                    如果还是true，继续执行循环体，直到布尔表达式结果为false，while循环结束。
            
        2 while循环有没有可能循环次数为0次？
            可能。当while的布尔表达式为false，那么他的循环次数就为0次
            while循环的循环次数是：0 ~ n 次
*/

public class WhileTest01{
    public static void main(String[] args){
        //死循环
        /*while(true){
            System.out.println("死循环");
        }*/
        
        // 本质上，while循环和for循环原理是相同的。
        /*
            for(初始化表达式;布尔表达式;更新表达式){
                循环体;
            }
            
            初始化表达式;
            while(布尔表达式){
                循环体;
                更新表达式;
            }
            
            if switch 属于分支语句属于选择语句
            for while do..while..这些都是循环语句。
            可以正常互相嵌套
        */
        
        /*int i = 0;
        while(i < 10){
            System.out.println("while ---> " + i);
            i++;
        }
        
        
        for(int k = 0 ; k < 10 ; k++){
            System.out.println("for --> " + k);
        }*/
        
        int i = 0;
        while(i < 10){
            i++;
            System.out.println("while ---> " + i);// 1 2 3 .. 9 10
        }
        
        for(int k = 0 ; k < 10 ; ){
            k++;
            System.out.println("for --> " + k);// 1 2 3 .. 9 10
        }
        
    }
}

do..while循环语句：

---------------------------------------------------------↓ do..while循环语句 ↓----------------------------------------------------------

/*
    do..while循环语句的执行原理以及语法机制：
        语法机制：
            do{
                循环体
            }while(布尔表达式);
            
            注意：do..while循环最后的时候不要漏掉“分号”
            
            执行原理：
                先执行循环体中的代码，执行一次循环体之后，判断布尔表达式的结果，如果为true，则继续自行循环体，如果为false循环结束。
            
            对于do..while循环来说，循环体至少执行一次。循环体的执行次数是1~n次。
            对于while循环来说，循环体的执行次数是：0~n次。
*/
public class DoWhileTest01{
    public static void main(String[] args){
        
        /*int i = 0;
        do{
            System.out.println(i);
            i++;
        }while(i<10);*/
        
        /*int i = 0;
        do{
            System.out.println(i++);
        }while(i<10);*/
        
        int i = 0;
        do{
            System.out.println(++i);
        }while(i<10);
        
    }
}

break转向语句：

---------------------------------------------------------↓ break转向语句 ↓----------------------------------------------------------

/*
    break;语句
        1 break;语句比较特殊，特殊在break语句是一个单词成为一个完整的java语句。
         另外 continue也是这样，他俩都是一个单词成为一条语句。
        2 break 翻译为折断、弄断的意思
        
        3 break;语句可以用在哪里呢?
            用在两个地方，其他位置不行
            第一个位置：switch语句当中，用来终止switch语句的执行。
                用在switch语句当中，用来终止switch语句的执行。
                
            第二个位置：break;语句用在循环语句当中，用来终止循环的执行。
                用在for当中
                用在while当中
                用在do..while当中
                
        4 以下程序主要是以for循环为例学习break转向语句
        
        5 break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离他最近的那个循环语句。
        
        6 怎么让break;语句终止指定循环呢？
            第一步: 你需要给循环起一个名字，例如:
                a:for(){
                    b:for(){
                    
                    }
                }
            第二步：终止：break a;    
            
*/
public class BreakTest01{
    public static void main(String[] args){
        
        /*for(int i = 0 ; i < 10 ; i++){
            
            if(i == 5){
                // break;语句会让离他最近的循环终止结束掉
                break;// break;终止的不是if,不是针对if的，而是针对离他最近的循环。
            }
            System.out.println("i == " + i);
        }
        System.out.println("Hello World！");*/
        
        /*for(int k = 0 ; k < 2; k++){
            for(int i = 0 ; i < 10 ; i++){
            
            if(i == 5){
                // break;语句会让离他最近的循环终止结束掉
                break;// break;终止的不是if,不是针对if的，而是针对离他最近的循环。
            }
            System.out.println("i == " + i);
            }
        }*/
        
        // 以下讲解的内容，以后开发很少用。不要紧张
        // 这种语法很少用，了解以下即可。
        a:for(int k = 0 ; k < 2; k++){
            b:for(int i = 0 ; i < 10 ; i++){
            
            if(i == 5){
                break a;// 这个a就代表你让谁结束，谁就结束
            }
            System.out.println("i == " + i);
            }
        }
        
    }
}

continue转向语句：

---------------------------------------------------------↓ continue转向语句 ↓----------------------------------------------------------

 

/*
    continue;语句：
        1 continue翻译为：继续
        2 continue语句和break语句要对比着学习。
        3 continue语句的作用是：
            终止当前“本次”循环，直接进入下一次循环继续执行。
            for(){
                if(){ // 当这个条件成立时，执行continue语句
                    // 结束本次循环，直接跳到下一次循环
                    continue; //当这个continue语句执行时，continue下面的代码不执行，直接进入下一次循环。
                }
                
                // 以上的continue一旦执行，那么下面的代码本次都不会执行，直接执行下一次循环。
                code1;
                code2;
                code3;
                code4;
                code5;
            }
            
        4 continue语句后面可以指定循环吗？
            可以的。
            这里就不再讲了，自己测试一下。
*/
public class ContinueTest01{
    public static void main(String[] args){
        
        System.out.println("--------break-----------");
        
        for(int i = 0 ; i < 10 ; i++){
            
            if(i == 5) {
                break;    
            }
            System.out.println(i);
        }
        
        System.out.println("--------continue-----------");
        
        for(int i = 0 ; i < 10 ; i++){
            
            if(i == 5) {
                continue;
            }
            System.out.println(i);
        }
    }    
}

猴子与桃子的练习：

---------------------------------------------------------↓ 猴子与桃子的练习 ↓----------------------------------------------------------

/*
    题目，猴子吃桃子
        猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个，
        以后每天早上都吃了前一天剩下的一半零一个，到了第十天早上想在吃时，只剩下一个桃子。求第一天共摘了多少个桃子。
*/
public class Test01{
    public static void main(String[] args){
        
        int day = 9;
        int TaoZi = 1;
        System.out.println("第10天有1个桃子");
        for(int i = day ; i > 0 ; i--){
            TaoZi = (TaoZi + 1) * 2;
            System.out.println("第" + day-- +"天有"+ TaoZi +"个桃子");
        }
    }
}