循环：
        for循环：
                格式： for（初始化表达式1；条件表达式2；控制条件3）｛
                                        循环体4；
                                ｝

                执行流程：
                        * a:执行初始化语句
                        * b:执行判断条件语句,看其返回值是true还是false
                                * 如果是true，就继续执行
                                * 如果是false，就结束循环
                        * c:执行循环体语句;
                        * d:执行循环后的操作表达式
                        * e:回到B继续。
                                               
                        练习题：
                                需求：在控制台输出数据1-10。
                                        思路：        1.循环数据1-10
                                                        2.输出循环到的数据
                                完成后思考怎么输出10-1。

                注意事项：
                        1.判断条件语句无论简单还是复杂，结果都是布尔类型。
                        2.大括号可以省略，只能控制他下面的一条语句，建议永远写上。
                        3.左大括号和分号只能有一个
                        4.在for循环中声明的变量（标准格式），在for执行完就释放掉了。


                        需求：求1-10之间数据之和。

                        思路：        1.定义一个变量用来记录数据和
                                        2.通过循环获取到数据1-10
                                        3.累加；
                                        4.输出和；

               
                        int sum = 0；
                        for (int i = 1; i <= 100; i+=2)｛
                                //if(i % 2 != 0) {//偶数 i % 2 == 0
                                        sum += i；
                                //}
                        ｝
                        System.out.println(sum);

                需求：在控制台输出所有的”水仙花数”。
                水仙花数：
                        三位数 100 ~ 999
                        其各个数位上的数字的立方和等于该数本身的一个三位数。
                       
                        153/10/10 % 10
                        153/10  % 10
                        153 % 10
                        153  =  1*1*1 + 5*5*5 +3*3*3


                        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.println(i+"是水仙花数");
                                }
                        }

                习题：
                统计水仙花数共有多少个，应该怎么做？

                while循环：
                        循环结构while语句的格式：
                                while循环的基本格式：
                                        while(判断条件语句) {
                                                循环体语句;
                                        }
                               
                                完整格式：
                                        初始化语句;
                                        while(判断条件语句) {
                                                 循环体语句;
                                                 控制条件语句;
                                        }
                        执行流程：
                                * a:执行初始化语句
                                * b:执行判断条件语句,看其返回值是true还是false
                                        * 如果是true，就继续执行
                                        * 如果是false，就结束循环
                                * c:执行循环体语句;
                                * d:执行控制条件语句
                                * e:回到B继续。

                        需求：使用while循环求1-100的和。
                        int i = 0；
                        while(i <= 100)；{
                                ?
                        }

                        注意：
                                1.判断条件语句结果必须是 布尔类型
                                2.初始化条件在循环结束后仍然可以使用
                                3.在小括号后面，有分号就不能有左大括号，有左大括号就不能有分号；


        do...while循环：
                循环结构do...while语句的格式：
                        基本格式：
                                do {
                                        循环体语句;
                                }while(判断条件语句);
                               
                        完整格式；
                                初始化语句;
                                do {
                                        循环体语句;
                                        控制条件语句;
                                }while(判断条件语句);
                执行流程：
                        * a:执行初始化语句
                        * b:执行循环体语句;
                        * c:执行控制条件语句
                        * d:执行判断条件语句,看其返回值是true还是false
                                * 如果是true，就继续执行
                                * 如果是false，就结束循环
                        * e:回到b继续。

                三种循环语句的区别:
                        1. do...while循环至少执行一次循环体。
                        2. 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
                        3.for循环初始化条件中的变量在循环执行完毕后就释放掉了；
               
                使用：
                        如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。
                        因为变量及早的从内存中消失，可以提高内存的使用效率。

        两种死循环：
                for (; ;){
                }

                while(true){}

        嵌套循环：
                外循环控制行数，内循环控制列数
                        需求：请输出一个4行5列的星星(*)图案。
                                for (int i = 0;i < 4 ; i++){  //行
                                        for (int j = 0;j < 5 ; j++){ //列
                                                System.out.print("*");
                                        }
                                        System.out.println();
                                }
                        需求：请输出下列的形状
                        *
                        **
                        ***
                        ****
                        *****
                                for (int i = 1;i <= 5 ; i++){  //行
                                        for (int j = 0;j < i ; j++){ //列
                                                System.out.print("*");
                                        }
                                        System.out.println();
                                }

                需求：在控制台输出九九乘法表。
                        1 * 1 = 1
                        1 * 2 = 2 2 * 2 = 4
                        ....
                        1 * 9 = 9 2 * 9 = 18 ..... 9 * 9 = 81

                for(int i = 1; i <=9 ;i++){
                        for(int j = 1;j <= i;j++){
                                System.out.print(j + "*" + i + "=" + j*i + "\t");

                        }
                        System.out.println();
                }

                转义符的使用：
                                        \t 制表符
                                        \r 回车
                                        \n 换行
                                        \"
                                        \'  或者 "'"

                控制跳转语句：
                        break：跳出循环
                                switch 和 循环中 使用
                        continue：结束本次循环，继续下一次循环。
                                只能在循环中使用

                带标号的跳转控制语句：
                        标号:标记某个循环对其控制
                        标号组成规则:其实就是合法的标识符
                        例子：
                        outer:for(int i = 1; i <=9 ;i++){
                                inner:for(int j = 1;j <= i;j++){
                                        System.out.print(j + "*" + i + "=" + j*i + "\t");
                                        break outer;
                                }
                                System.out.println();
                        }

                return的作用：
                        返回
                        其实它的作用不是结束循环的，而是结束方法的。

                        return和break以及continue的区别：
                                 return是结束方法
                                 break是跳出循环
                                 continue是终止本次循环继续下次循环


        方法：
                概述：完成特定功能的代码块；
                作用：提高代码复用性；
                格式：
                        修饰符 返回值类型 方法名（参数类型1 参数名1，参数类型2 参数名2......）{
                                方法体语句；
                                return 返回值；
                        }
                方法的格式说明
                        * 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
                        * 返回值类型：就是功能结果的数据类型。
                        * 方法名：符合命名规则即可。方便我们的调用。
                        * 参数：
                                * 实际参数：就是实际参与运算的。
                                * 形式参数；就是方法定义上的，用于接收实际参数的。
                        * 参数类型：就是参数的数据类型
                        * 参数名：就是变量名
                        * 方法体语句：就是完成功能的代码。
                        * return：结束方法的。
                        * 返回值：就是功能的结果，由return带给调用者。
                如何写一个方法
                        1,明确返回值类型
                        2,明确参数列表
                方法调用(有具体返回值)：
                        单独调用：一般来说没有意义，所以不推荐。
                        赋值调用：推荐方案。
                        输出调用：但是不够好。因为我们可能需要针对结果进行进一步的操作。
                方法调用：(无返回值,void)
                        单独调用
                        输出调用(错误)
                        赋值调用(错误)
                方法使用过程中需要注意：
                        1:方法不调用不执行
                        2:方法与方法是平级关系，不能嵌套定义
                        3:方法定义的时候参数之间用逗号隔开
                        4:方法调用的时候不用在传递数据类型
                        5:如果方法有明确的返回值，一定要有return带回一个值

                习题：        1、需求：键盘录入两个数据，返回两个数中的较大值
                                2、需求：键盘录入两个数据，比较两个数是否相等  
       
        方法的重载：
                概述：在同一个类中，方法名相同，参数列表不同，与返回值无关；

                参数列表不同：
                        1.参数个数不同
                        2.参数类型不同
                                参数顺序不同

不错哦！