day04

1.break

        break 两种用法

                在循环中,用于结束循环,在switch中,用于结束case分支

                  for (int i = 0; i < 10; i++) {

                    System.out.println(i);

                    if (i == 3) {

                        System.out.println("找到了");

                        / / 终止循环执行

                // 假如我们需要在一堆数据中查找某个数据,

                // 当我们找到后,就没有必要再往下执行了,可以通过break终止

                break;

            }

        }

2.Continue

        

// continue 是跳过当前次循环

        // continue 是跳过当前次循环,不再执行循环体,直接执行i++ 不再执行这次的循环

        for (int i = 0; i < 10; i++) {

            if (i == 3) {

                continue;

            }

            System.out.println(i);

        }

3.BreakOutfor

// 默认的break和continue都是操作的内层循环

        // 如果想要让break和continue操作对应的外层循环

        // 需要对外层循环设置个名字,然后通过 break 名字 ; continue 名字; 来操作对应的循环

        outFor: for (int i = 0; i < 5; i++) {

            for (int j = 0; j < 5; j++) {

                if (j == 2) {

                    break outFor;

                    // continue outFor;

                }

                System.out.print(j + " ");

            }

            System.out.println();

        }

4.方法

     4.1概述和作用             

         * 方法 : 就是一堆代码的集合,一般一个方法用于完成一个特定的功能

         * 优点 : 代码复用,易维护,易扩展,灵活度提高

     4.2方法声明        

* 声明 : 

 *         修饰符列表  返回值类型  方法名  (参数列表) { 方法体 }

 * 

 *         修饰符列表 : 可以有,可以没有,可以有多个(空格隔开),不区分顺序

 *             权限控制 : public  private protected  不写  四选一

 *             static  修饰静态,不加就是成员

 * 

 *         返回值类型 : 可以写十一种数据类型中任意一种,如果没有返回值,则写void

 *                 void表示没有返回值

 * 

 *         方法名 : 符合命名规则即可

 *     

 *         参数列表 : 

 *             可以没有,可以有多个,多个用逗号隔开

 *             参数列表中的变量也是局部变量

 * 

 *         方法体 : 就是方法中的功能代码

 *         return : 终止方法运行,并返回结果

 *             如果 方法有返回值类型,则方法体内必须有return语句

 *                     假如返回值类型为int   , 则 必须有一个 " return  int值; "

 *                     并且 该语句 可以把数据返回给调用处,同时还会终止方法运行

 *             如果方法没有返回值类型,则可以有return也可以没有

 *                 如果要写return,也只能做到终止方法运行的功能,不能返回数据

          

   4.3方法的分类

* 分类 : 

 *         成员方法 : 没有使用static修饰的方法

 *         静态方法 : 使用static修饰的方法

 *         构造方法 : 先不管,对象再说

                

4.4方法的调用

        

 * 调用 : 

 *         静态方法 : 类名.方法名(参数)  同类中类名可以省略

 *         成员方法 : 对象.方法名(参数)

4.5入参和出参

 * 形参 : 形容参数,方法声明时,指定的参数列表,称为形参

 * 

 * 实参 : 实际参数,调用方法时,传入的具体数据

 * 

 * 入参 : 参数列表,也就是调用这个方法的时候,需要传入什么数据

 * 

 * 当我们要做某一件事的时候,需要用到的必备的未知数据,可以写到参数列表中

 * 出参 : 返回值,也就是方法执行完之后,需要返回的数据

 * 

 * 当我们做完某件事之后,需要返回的数据,是返回值(出参)

 * 

 * 一般是返回方法中的打印语句

 * 

 * 方法 只保证功能的实现,最终这个方法被用在什么地方,与声明无关

    public static void main(String[] args) {

        m1();

        m2(10);

        int result = m3(1, 10);

        System.out.println(result);

    }

    // TODO : 需求 : 计算1~100的累加加和并打印

    public static void m1() {

        int sum = 0;

        for (int i = 1; i <= 100; i++) {

            sum += i;

        }

        System.out.println(sum);

    }

    // TODO : 需求 : 计算1~M的累加加和并打印

    public static void m2(int m) {

        int sum = 0;

        for (int i = 1; i <= m; i++) {

            sum += i;

        }

        System.out.println(sum);

    }

    // TODO : 需求 : 计算N~M的累加加和并返回,假设 m > n

    public static int m3(int n, int m) {

        int sum = 0;

        for (int i = n; i <= m; i++) {

            sum += i;

        }

        return sum;

    }

4.6方法的重载

   

 * Overload : 方法重载

 * 

 * 方法名相同,参数列表不同,就是方法重载

 * 

 * 参数列表不同分为两种

 *         1 个数不同  , 2 类型不同

 * 

 * 优点 : 功能相同,名字相同,方便记忆,代码美观

    public static void main(String[] args) {

        sumInt(10,20);

        sumDouble(10.2,20.2);

        sumLong(29L,33L);

        // 重载之后

        sum(10,20);

        sum(10.2,20.2);

        sum(29L,33L);

        

        // 以下也是方法重载

        System.out.println("你好");

        System.out.println(10);

        System.out.println(10.95);

        System.out.println(false);

    }

    public static void sumInt(int a, int b) {

        System.out.println(a + b);

    }

    public static void sumDouble(double a, double b) {

        System.out.println(a + b);

    }

    public static void sumLong(long a, long b) {

        System.out.println(a + b);

    }

    

    // 重载之后

    public static void sum(int a, int b) {

        System.out.println(a + b);

    }

    public static void sum(double a, double b) {

        System.out.println(a + b);

    }

    

    public static void sum(long a, long b) {

        System.out.println(a + b);

    }

4.7方法调用时的转换

      

    public static void main(String[] args) {

        // 自动类型转换

        // 由于前面是double, 所以后面的9 会转换为double 匹配 double对应的方法

        m1(1.5, 9);

        // 由于两个都是int , 所有 转换为long, 而不是double

        m1(1, 2);

    }

    public static void m1(long a, long b) {

        System.out.println("long....");

    }

    public static void m1(double a, double b) {

        System.out.println("double....");

    }

    // public static void m1(int a , long b){

    // System.out.println(111);

    // }

    // public static void m1(long a , int b){

    // System.out.println(222);

    // }

5.内存分析

        

 JVM运行时区域

 * 

 *         程序计数器

 *             暂时不管

 * 

 *         静态区/方法区

 *             用来保存运行时的class文件及静态属性和 方法的

 * 

 *         VM栈:是以栈数据结构为模型,开辟的一块空间

 *             先进后出,类似于弹夹,第一个放的子弹是最后一枪打出来的

 *                 栈帧 : 在栈内存中保存的数据空间

 *                     如果VM栈就是弹夹的话, 栈帧就是弹夹中的每一个子弹

 *                 栈底元素 : 第一个放入栈空间的栈帧

 *                 栈顶元素 : 最后一个放入栈空间的栈帧

 *                 压栈 : 把栈帧放到栈空间的过程,叫压栈

 *                 弹栈 : 把栈帧在栈空间中弹出的过程,叫弹栈

 * 

 *             用于执行方法,每一个方法调用,就是一个栈帧

 *                 一般 main方法为栈底元素

 *             方法调用就等于压栈,方法执行完成就等于弹栈

 *         

 *         堆内存

 *             用于保存对象的(包括成员属性)

 *         

 *         本地方法栈

 *             和VM栈一样,只不过用于执行本地方法,不用管

6.递归

         6.1递归的概述和基本应用

               

 * 递归 : 递归就是在方法中调用当前方法

 * 

 * 直接递归 : 当前方法中对自身方法进行调用

 * 

 * 间接递归 : A调用B,B调用A

 * 

 * 递归和迭代(循环)是等价的,都需要终止条件,否则就是死循环

 * 

 *  java.lang.StackOverflowError : 栈内存溢出,一般是因为一直压栈并没有弹栈导致

 *  

 *  1 递归没有终止条件,出现了死循环

 *  

 *  2 递归代码没有问题,但是因为要计算的功能比较大,导致压栈过多

 *  

 *  递归是比较消耗内存的算法,效率较低,所以能使用循环解决的问题,尽量不要使用递归

 *  

 *  循环能做的,递归都能做,但是递归能做的,循环不一定能做 , 但是只要循环能做,就不用递归

 *  

 *  一般树状结构一类的,循环都搞不定,都需要用递归去做,比如文件夹的嵌套关系

 *  

 *  例如 : 要获取某文件夹下,所有的文件(包含子文件)

6.2计算1~n的和

    

6.3斐波那契数列 

        

 * 斐波那契数列

 * 前两位是1 , 后续每一位都等于前两位的和

 * 

 * 1  1  2  3  5  8  13  21  34  55  89 ....

 * 

 * 有一对兔子,从第三个开始,每个月生一对兔子

 * 新生的兔子也是从第三个月开始,每个月生一对兔子

 * 问,15个月后,有多少对兔子