Day04 --循环语句 方法

 a.
    循环结构
        for, while, do...while
    循环结构之for
        for(初始化表达式;条件表达式;循环后的操作表达式;){
                循环体;
        }
    执行流程:
        1) 先执行初始化表达式。
        2）再执行条件表达式，看结果是true还是false；
            a.如果是true,就执行循环体;
            b.如果是false,就结束循环;
        3) 如果是true,执行完后循环体，再去执行循环后的操作表达式，
        4）当循环后的条件表达式满足条件表达式的话，再去执行2）如此循环下去。
    
    注意事项：
        1）条件表达式中，无论复杂还是简单，结果都是boolean类型。
        2）循环体如果是一条，大括号可以省略，如果是多条，不能省略，建议都不省略。
        3) 一般来说，有左大括号，就没有分号，有分号就没有左大括号。

--例子--：
    目录：
        1）Demo1_循环语句for 
        2）Test1_循环语句for
            * 需求：请在控制台输出数据1-10
            * 需求：请在控制台输出数据10-1
        3）Test2_循环语句for
            * 需求：求出1-10之间数据之和
            * 需求：求出1-100之间偶数和
            * 需求：求出1-100之间奇数和
        4）Test3_循环语句for_水仙花数
             
    路径：    
        G:\CSDN_Android_\Code\day04\07_循环结构for



    --循环语句while
        格式：
            初始化语句;
            while(条件表达式){
                循环语句;
                条件控制语句（循环后的操作表达式）；
            }
    
        执行流程：
            a.先执行初始化语句；
            b.再判断while中的条件表达式，看结果是true还是false
                如果是true,就执行循环语句；
                如果是false，就跳出循环体；
            c.如果是true，执行完循环语句后，再执行控制语句。
            e.然后再返回b，如此循环下去。

--例子-：
    目录：
         Demo1_循环语句while
            * 需求：请在控制台输出数据1-10
         Test1_循环结构while语句的练习
            * 需求：求和思想
            * 统计”水仙花数”共有多少个
    路径：
        G:\CSDN_Android_\Code\day04\08_循环结构while

​    

    --循环语句 do...while(条件表达式)
        格式：
            do{
                循环语句；
                循环后的条件表达式；
            }while(条件表达式)；
    
        执行流程：
            a. 先执行循环语句；
            b. 再执行循环语句后的条件表达式。
            c. 将条件表达式的结果与while的条件表达式做比较，看结果是true还是false。
                    如果是true，就继续执行b.
                    如果是false，就结束循环体。
--例子：
    目录：
        Demo1_循环语句do_while
            * 需求：请在控制台输出数据1-10
    路径：
        G:\CSDN_Android_\Code\day04\09_循环结构do while\Demo1_循环语句do_while.java


    --循环语句 do...while
    格式：
        do{
            循环语句；
            循环后的条件表达式；
        }while(条件表达式);
    
    执行流程：
        a. 先执行循环语句；
        b. 再执行循环后的条件表达式。
        c. 将条件表达式的结果与条件表达式做比较，看结果是true还是false。
                如果是true，就继续从b开始执行.
                如果是false，就结束循环体。
--例子：
目录：
    Demo1_循环语句do_while
路径：
    G:\CSDN_Android_\Code\day04\8_循环结构do while\Demo1_循环语句do_while.java




        for,while,do...while的区别？
            do...while  无论条件是否满足，必须先执行一次循环体；
            而for,while 是先看条件表达式是否满足条件，如果满足就执行，如果不满足，就不执行。
    
        for与while的区别？
            如果想在循环结束后，继续使用该变量，就使用while，如果不清楚循环后还使不使用该变量，就使用for，因为for在内存中会被及时的回收，这样可以节省内存空间，从而提高内存的使用效率。
        看下面就能看出来：
for:    
            for(int i = 0;i<=10;i++){
                    System.out.println(i); // 
                }
                    System.out.println(i); // 报错，因为i已经被回收
while:
            int a =  1;
            whlie(a<=10){
                System.out.println(a); //1到10
                a++;
            }
                System.out.println(a);//a = 11;




        死循环
            while(true){ //表示while的条件表达式的结果永远是true。
            }
    
            for(;;){ //
            }
    
        死循环的注意事项：
            如果使用死循环，但是下面还有程序，那么就会运行报错，因为在死循环的条件下，下面的程序是不会被执行到的，必须在满足某个条件跳出循环的情况下才能继续下面的程序。


b.    
        for循环语句的嵌套
            原则：
                1）外层控制行数，内层控制列数。
                2）明白print和println的区别，println换号输出，print不换号输出
--例子：
目录：
    Demo1_ForFor_5行4列正方形_5行4列直角三角形_5行4列倒直角三角形 
    Demo2_ForFor_九九乘法表

路径：
    G:\CSDN_Android_\Code\day04\10_循环嵌套\Demo1_ForFor_5行4列正方形_5行4列直角三角形_5行4列倒直角三角形.java

       九九乘法表：
            注意事项：
                转义符：
                    '/x' x表示任意字母， /表示转义符号，合起来叫：转移字符。
            常见转义符：
                    '/t' tab键的位置
                    '/r' 回车
                    '\n' 换行
                    '\"'
                    '\''
--例子：
    目录：
        Demo2_ForFor_九九乘法表
    路径：
        G:\CSDN_Android_\Code\day04\10_循环嵌套\Demo2_ForFor_九九乘法表.java


​        

c.    
        break;
            在switch和循环中使用。
        作用：
            在switch中使用时,表示为了防止case穿透。
            在循环中使用时,表示跳出循环体；
例子：
    //switch
        int x=3;
        switch(x){
            case 1:
                System.out.println("1");
            break;
            case 2:
                System.out.println("2"); 
            break;
            case 3:
                System.out.println("3");//他是结果
            break;
        }
    //for
        for(int i = 1;i <= 10;i++){
            if(i==7){
                break;
            }
            System.out.println(i);//结果1到6
        }
    
        continue
            只能在循环中使用；
        作用
            跳出本次循环，继续下一次循环。
例子：    
        for(int i = 1;i<=10;i++){
            if(i==7){
                continue; //跳出本次循环，继续下一次循环，
            }
            System.out.println(i);//结果：除了7，其他的都输出了
        }



    控制语句的标号：
        "a:" a就是标号，只要是合法的标识符即可。
             场景：
                1）用于循环嵌套的指定跳出，如跳出某一层循环，大多数用于跳出外循环。
                2）记住标号在控制台中不会被输出。
特殊例子:
    //标号不会被输出。
        System.out.println("呵呵");
        http://www.baidu.com  //这里不是网站，只是一个http:的标号，和一个//单行注释而已，记住标号在控制台中不会被输出。
        System.out.println("哈哈");
        /*
            结果：呵呵
                 哈哈
        */

--其他例子：
    路径：
    G:\CSDN_Android_\Code\day04\11_控制语句_break_continue_return\Demo3_控制语句的标号.java

--特殊案例：Test1_选择使用控制语句_break_continue_return_在循环中输出指定次数的循环体
//需求：选择使用控制语句分别输出2次，7次，13次
        for(int x=1; x<=10; x++) {
                if(x%3==0) {
                    //在此处填写代码
                    //break; //2次     //i=3的时候，才终止循环，所以使用break，所以输出2次，使用break。
                    //continue;//7次   //只有在i=3,6,9的时候，才跳出本次循环，继续下一次循环，所以输出7次，使用continue。
                    //System.out.println("Java基础班"); //13次 因为只有i=3,6,9的时候才进if，想输出13次，就使用直接输出：System.out.println("Java基础班");
                }
                System.out.println("Java基础班"); 
            }



    return
        场景：
            在方法中使用。
        作用：
            用于对所有方法的返回和带有数据类型的方法返回值的显示。
--例子:    
        for (int i=0;i<=10 ; i++) {
            if(i==5){
                //break;        //结果输出：Hello World! 因为只是将for循环结束，而程序还继续往下走。
                return;        //结果什么都没有，因为return将整个主方法都返回了
            }
        }
        System.out.println("Hello World!");



控制语句 break,continue,return的区别？
    break: 用于switch和循环中，是跳出循环。        
    continue：用于循环中，是跳出本次循环，继续下一次循环。
    return: 用于结束方法。


d.
        方法
            为什么要使用：
                是为了提高代码的复用性。
            什么是方法：
                完成特定功能的代码块。
            格式：
                修饰符 返回值类型 方法名(参数类型 参数1,参数类型 参数2...){
                    方法语句体;
                    return 返回值;
                }
            格式说明：
               修饰符: 目前 public static，具体后面说其他修饰符。
            返回值类型: 功能结果的数据类型，可以是void，也可以是基本数据类型，也能是引用数据类型。 
                方法名: 自己起的名字，合法标识符命名规则即可。
                  参数: 分实参（实际参数）和形参（形式参数）
                       * 实参： 传具体的值，参与实际运算的。
                       * 形参： 方法上括号里定义的，用于接收实际参数。
              参数类型: 参数的数据类型，可以是基本数据类型，也能是引用数据类型。
                参数名: 变量名，必须与参数类型匹配，如果是int,那么参数名只能是整数，如果是double,参数只能是小数,也能是引用数据类型。
             方法体语句: 特定功能的代码块。
               return: 结束方法用的。
                返回值：必须与返回值类型匹配，如果返回值类型是void，就没有return,或返回空：return,如果有返回值类型是基本数据类型，return后面跟的值也是基本数据类型，如果是引用数据类型，return后面的值也是引用数据类型。
    
        函数
            概念
                就是定义在类中具有特定功能的一段独立的小程序，也叫方法。
            格式
                修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2）{
                    执行语句。
                    return 返回值；
                }
    
            返回值类型： 函数运行后的结果的数据类型。
            参数类型：是形式参数的数据类型。
            形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
            实际参数：传达给形式参数的具体数值。
            return:用于结束方法。
            返回值：该函数运行后的结果，将结果返回给调用者。
    
        特点
            1）定义函数可以将功能代码进行封装。
            2）便于对功能进行复用。
            3）函数只有被调用的时候才执行。
            4）函数的出现提高了代码的复用性。
    
        p.s.
            1）对于函数没有具体返回值的情况，返回值类型关键字void来表示，那么该方法中的return语句如果在最后一行就能省略，或者直接return;。
            2）函数中只能定义函数，不能再函数内部中定义函数，可以调用函数，他们是同级关系。
            3）定义函数时，函数的结果应该返回给调用者，交给调用者进行处理。
    
        函数的应用
            两个明确：
                1） 要明确定义的功能最后的结果是什么？

例子
    目录：
        Demo1_方法method
    路径：
        G:\CSDN_Android_\Code\day04\12_方法\Demo1_方法method.java


        方法调用的注意事项：
            1) 如果方法有返回值，单独调用，没意义，不推荐，如：main{ add(a,b)}
            2) 输出调用，不太好。因为不能对结果进行进一步操作，如：main{ sop(add(a,b))}
            3) 输出调用，推荐。明确return结果的类型，匹配调用。main{int a = add(a,b) 结果a再与别的参与运算}
        
            4）方法不调用，不执行。
            5）方法与方法是平级关系，不能嵌套定义，每个方法都是单独存在。但可以嵌套调用，方法语句过程中调用方法。
            6）方法调用的时候，不用传递数据类型，实参即可。
            7）如果方法有明确的返回值，return必须带回一个匹配返回值类型的值。

--特殊例子：
    目录：
        1） Demo1_方法method
        2） Test1_方法method
            * 需求：键盘录入两个数据，返回两个数中的较大值
            * 需求：键盘录入两个数据，比较两个数是否相等 
        3） Test2_根据键盘录入的行数和列出输出对应的星形
        4） Test3_方法method_九九乘法表     
    
    路径：G:\CSDN_Android_\Code\day04\12_方法
        方法调用：void
            单独调用，返回值类型用void。main{ jiujiu(9,9)}
            输出调用（错误）
            赋值调用（错误）


e.        
    方法的重载
        重载：
            在一个类中，出现 方法名相同，参数列表（参数类型，参数个数）不同，与返回值类型无关的方法。
        参数列表不同：
            a.参数类型不同；
            b.参数个数不同；
                * 参数顺序不同【算重载，但在开发中不用】
例子
    求和案例
        * 2个整数
        * 3个整数
        * 4个整数
    路径：G:\CSDN_Android_\Code\day04\13_方法的重载\Demo1_方法的重载overload.java