黑马程序员技术交流社区

标题: 【南京校区】判断和循环 [打印本页]

---

作者: 大蓝鲸Java    时间: 2019-5-24 13:07
标题: 【南京校区】判断和循环
1.if的格式3
         格式：
                if(){
                        ...
                }else if(){
                        ...       
                }...
                else{
                        ...       
                }

注意点：
        1.每一个小括号中都必须都是一个关系表达式，必须有一个布尔类型的结果。
        2.加载顺序
                会从第一个关系表达式开始匹配，依次往下匹配。
                如果有一个为true，那么执行对应的语句体，执行完毕后，表示这个整体就执行完毕了。
                "依次匹配"
                        简单来说，只要有一个为true，下面的表达式都不会继续匹配了。

练习1：
        int x = 2;
        if(x == 5){
                System.out.println("AAA");
        }else if(x == 10){
                System.out.println("BBB");
        }else if(x == 15){
                System.out.println("CCC");
        }else if(x == 20){
                System.out.println("DDD");
        }else if(x == 25){
                System.out.println("EEE");
        }else{
                System.out.println("FFF");
        }


练习2：
        int x = 10;
        if(x == 10){
                System.out.println("AAA");
        }else if(x == 10){
                System.out.println("BBB");
        }else if(x == 10){
                System.out.println("CCC");
        }else if(x == 10){
                System.out.println("DDD");
        }else if(x == 10){
                System.out.println("EEE");
        }else{
                System.out.println("FFF");
        }

        //AAA



2.switch结构
        总结：
                1.具体格式。小括号中能写什么。"byte short int char String"
                2.加载顺序。执行的时候，会把所有的case"同时加载"到内存中。直接执行跟表达式相同的那个case。
                                        "case不能重复"
                3.case穿透。
                                在执行switch中case语句体的时候，会遇到break或者右大括号停止。
                                如果没有遇到，继续执行下一个case的语句体。直到遇到break或者右大括号停止。

                        应用场景：
                                当多个case的语句体重复的时，可以使用case穿透来减少代码量。
               
       


        格式：
                switch (表达式){
                        case 值1:
                                语句体1;
                                break;//跳出整个switch语句。
                        case 值2:
                                语句体2;
                                break;//跳出整个switch语句。
                        ...
                       
                        default :
                                语句体n;
                                break;
                }
               



练习：
        int x = 10;
        switch (x){
                case 1:
                        System.out.println("AAA");
                        break;
                case 2:
                        System.out.println("BBB");
                        break;
                case 3:
                        System.out.println("CCC");
                        break;
                case 4:
                        System.out.println("DDD");
                        break;
                case 5:
                        System.out.println("EEE");
                        break;
                default :
                        System.out.println("default");
                        break;
        }
       
        当case后面的值跟小括号中的结果都不一样的时候，此时会执行default。



        int x = 5;
        switch (x){
                case 5:
                        System.out.println("AAA");
                        break;
                case 5:
                        System.out.println("BBB");
                        break;
                case 5:
                        System.out.println("CCC");
                        break;
                case 5:
                        System.out.println("DDD");
                        break;
                case 5:
                        System.out.println("EEE");
                        break;
                default :
                        System.out.println("default");
                        break;
        }


3.case穿透
        不是一个错误，而是一个知识点。
        在正常情况下，会执行对应case的语句体，一直执行到break或者右大括号为止。
        如果在执行的过程中没有遇到break，会继续执行下面的语句体，直到遇到break或者右大括号为止。

        应用场景：case语句体重复。


练习：
        练习1：
                int a = 1;
                switch (a){
                        case 1:
                                System.out.println(111);
                                break;
                        case 2:
                                System.out.println(222);
                                break;
                        case 3:
                                System.out.println(333);
                                break;
                        default :
                                System.out.println("AAA");
                                break;
                }
        结果：
                111





        练习2：
                int a = 1;
                switch (a){
                        case 1:
                                System.out.println(111);
                        case 2:
                                System.out.println(222);
                        case 3:
                                System.out.println(333);
                                break;
                        default :
                                System.out.println("AAA");
                                break;
                }
        结果：
                111
                222
                333






        练习3：
                int a = 5;
                switch (a){
                        case 1:
                                System.out.println(111);
                        case 2:
                                System.out.println(222);
                        case 3:
                                System.out.println(333);
                                break;
                        default :
                                System.out.println("AAA");
                                break;
                }
        结果：
                AAA

       







        练习4：
                int a = 5;
                switch (a){
                        case 1:
                                System.out.println(111);
                        case 2:
                                System.out.println(222);
                        case 3:
                                System.out.println(333);
                                break;
                        default :
                                System.out.println("AAA");
                }
        结果：
                AAA


练习5：
        int a = 5;
        switch (a){
                default :
                        System.out.println("AAA");
                case 1:
                        System.out.println(111);
                case 2:
                        System.out.println(222);
                case 3:
                        System.out.println(333);
        }
结果：
        AAA
        111
        222
        333

       
        在语法中，default是没有上下顺序的，表示所有的case都不匹配的时候就执行。
        但是我们习惯性的会把default写在最下面。
       

        答案解析：
                1，会看有没有跟5匹配的那个case。此时发现是没有的。
                2，执行default，打印AAA。打印完毕之后没有break也没有遇到右括号
                3，会穿透执行下面case的语句体，打印111，打印完毕之后没有break也没有遇到右括号
                4，会穿透执行下面case的语句体，打印222，打印完毕之后没有break也没有遇到右括号
                5，会穿透执行下面case的语句体，打印333，打印完毕之后发现了右大括号，所以停止。


4.循环
        重复的执行一段代码。



5.for结构
        //非常的重要
        格式
                for (初始化语句 ; 条件判断语句 ; 控制语句){
                        循环体;
                }
       

        问：
                初始化语句，条件判断语句，循环体，控制语句分别执行多少次？
                循环次数未知。N次。



                初始化语句：只能执行一次。且必须执行一次。

                条件判断语句：比循环次数多一次。

                循环体：跟循环次数一致。

                控制语句：跟循环次数一致。



7.for的求和案例
        案例:
                int sum = 0;
                for (int i = 1; i <= 5 ; i++ ){
                       
                        sum = sum + i;
                }
                System.out.println(sum);

       
       

        问：
                当变量定义在循环外，循环上，循环内的作用范围和区别？
                int outer = 10;
                for (int i = 20; i <= 50 ; i++ ){
                        int inner = 30;
               

                }

                当变量定义在循环外：outer
                        表示在循环的过程中，只有这样的一个变量。在循环结束之后依旧可以使用。


                当变量定义在循环上：i
                        表示在循环的过程中，只有这样的一个变量。在循环结束之后就不能使用了。
               
                当变量定义在循环内：inner
                        表示在循环的过程中，有多个这样的变量。每次循环都会定义一个新的inner
                        作用范围：只能在本次循环中有效。
                        如果循环10次，那么在内存中有10个inner。

               


举例：
        如果求1-5之间的和
       
         for (int i = 1; i <= 5 ; i++ ){
                 int sum = 0;//求和变量不能定义在里面。
                                        //因为每一次循环都是一个新的sum。
                 sum = sum + i;
         }



8.水仙花案例的变形
//我要把这些水仙花打印在控制台上，每一行打印两个。
public class Demo{
        public static void main(String[] args) {
                int count = 0;
                for(int i=100; i<1000; i++) {
                        int ge = i%10;
                        int shi = i/10%10;
                        int bai = i/10/10%10;
                        if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                                //打印水仙花
                                System.out.print(i + " ");
                                //用来统计现在是第几个水仙花数
                                count++;
                                //如果是第2个，第4个，那么就换一行吧。
                                if(count%2 == 0){
                                        System.out.println();
                                }
                        }
                }
    }
}



9.while循环

        while(判断条件语句){
                循环体;
        }


        注意点：
                1.for循环跟while循环可以互相替换的。
               
                2.在语法中，两者完全可以互相替代，但是在平时的使用习惯上，是有区别的。

                        当知道循环次数的时候，使用for循环。
                        当不知道循环次数，但是知道循环停止的条件，用while循环。


                        //我让用户判断录入 1- 10 之间的数。
                        //如果录入错了，那么一直录入，直到录入正确为止。


                        Scanner sc = new Scanner(...);
                        while(true){
                                int number = sc.nextInt();
                                if(number >= 1 && number <= 10){
                                        //结束。不让用再录了
                                }else{
                                        //表示数据错误，让用户继续录
                                }
                        }



10. do...while//这个循环了解即可，但是需要知道他的特点
        特点掌握：
                不管判断语句是真还是假，循环体至少执行一次。



11.三种循环的区别
        在语法中for和while其实是没有本质的区别的。
        只不过在使用习惯上有一些区别。
        for：知道循环次数
        while：知道停止条件


12.死循环/无限循环
        格式：
                while(true){
               
                }


                for (; ; ){ //判断语句空着默认认为是true
                }

        问：
                你觉得那种格式更适合实际开发？while(true){}
                无限循环，那么就是不知道次数的循环。所以此时用while更符合习惯。
               
                //给他一个停止的条件，比如：海枯石烂
                while(true){
                        if(海枯石烂了吗？){
                                停止循环。
                        }else{
                                继续循环。       
                        }
                }
       
13.continue 和 break的区别
        continue：停止本次循环，继续下次循环。
        break：直接将循环全部结束。

        细节：
                不管是continue还是break都不能单独出现。

                continue 只跟循环有关。

                break 可以写在 switch 里面和循环里面。

14.循环嵌套
        一般是两层循环。称之为外循环和内循环。
        要知道外循环表示什么？
        要知道内循环表示什么？
        把内循环当做是外循环的一个循环体。

        练习：
                *****
                *****
                *****
                *****
                *****
               
                //控制的数行数
                //可以把内循环看做是一个整体，这个整体就是外循环的循环体。
                for (int i = 1; i <=5 ; i++){
                        for (int j = 1; j <=5 ; j++ ){
                                System.out.print("*");
                        }
                        System.out.println();
                }

               
                理解：
                //我把打印一行*的代码循环5次。
                for (int i = 1; i <=5 ; i++){
                        //打印一行*
                }

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2