方法-重载-递归-内存

1. 方法

1.1. 概述和作用

方法 : 一堆代码的集合 , 创建空间存储 , 并设置名字 , 可以通过名字查找

目的 : 代码复用、易维护、易扩展、更灵活

1.2. 方法声明

方法声明 : 修饰符列表 返回值 方法名 (参数列表) { 方法体 }

修饰符列表 : 可以有,可以没有,可以有多个 , 虽然可以有多个 , 但是有些是不能同时出现的 , 多个修 饰符没有先后顺序

权限控制相关 , 四选一 : public、private、protected、不写(默认包权限)四选一

static 表示静态 , 不加则为成员

synchronized、final、abstract ... 但是final和abstract不能同时出现

返回值类型 : 执行完之后是否要将结果反馈给调用处, 可以写11种数据类型中的任意一种 , 如果不要返回值则写void

要返回的数据是什么类型 , 这里就写什么类型 , 没有则写void

如果指定了返回值 , 则方法体内必须有return语句

return :

1.终止方法运行

2.将数据返回到调用处

比如 返回值类型为 int类型 那么 方法体中 必须有 return int值;

如果是void, 则不需要有return, 就算要写return,那么此时只能终止方法运行,不能返回数据 return;

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

参数列表 : 可以有多个 , 也可以没有 , 多个用逗号隔开

1.3. 方法分类

方法分类 :

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

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

构造方法 :

        public static void m1(){

        System.out.println("静态方法");

        }

        public void m2(){

        System.out.println("成员方法");

        }

1.4. 方法调用

方法调用 :

方法不调用不执行 , 调用才会执行 , 并把执行结果返回给调用处

前缀 . 方法名( 参数 )

静态方法 : 类名 . 方法名(参数) , 如果调用当前类中的静态方法,类名可以省略

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

        m1();

        Method_02.m1();

        public static void m1(){

                System.out.println("静态方法");

        }

        public void m2(){

                System.out.println("成员方法");

1.5. 入参出参

入参 : 参数列表(xxx) , 需要用到的必要的未知条件(未知数据)

出参 : 返回值 , 完成功能后的打印语句 , 一般是需要返回的数据

        public static void main(String[] args) {

                m1();

// 接收返回值,m3的返回值类型为int,所以 使用int类型来接收返回值

                int result = m3(10);

                result = m4(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-100的加和,并返回

        public static int m2() {

                int sum = 0;

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

                        sum += i;

        }

        return sum;

// return 会终止方法运行,所以return后不能写代码

// System.out.println(2);

}

// TODO 计算1~m的加和,并返回

        public static int m3(int m) {

                int sum = 0;

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

                        sum += i;

        }

        return sum;

}

// TODO 计算n~m的加和,并返回,假设 n小于m

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

                int sum = 0;

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

                        sum += i;

        }

        return sum;

}

1.6. 方法重载

方法的唯一性 : java中方法可以重名

方法重载 : 方法名相同 , 参数列表不同

个数不同或类型不同

目的 : 使用方便 , 相同功能 , 相同方法名 , 方便记忆

        public static void main(String[] args) {

// 方法重载

                System.out.println(123);

                System.out.println(false);

                System.out.println("性能查看的");

        }

        public static void m1(){

        }

        public static void m1(int a){

        }

        public static void m1(double d){

        }

        public static void m1(double d,int a){

        }

2. 内存分析

java在运行时 进行的内存划分

静态区 / 方法区 : 保存静态资源文件 , 比如静态变量 , 方法 , 运行时的class文件等

        VM栈 : 以栈数据结构为模型 , 创建一块空间 , 主要用于执行方法

                栈数据结构特征 : 先进后出

                        栈顶元素 : 最后放进去的

                        栈底元素 : 第一个放进去的

                        栈帧 : 栈数据结构中的元素 , 称为栈帧

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

                弹栈 : 把栈帧在栈空间弹出去的过程

每当调用一个方法的时候 , 该方法就会在栈内存中开辟一个栈帧 , 并压栈到栈空间 , 开始执行 , 方法执行完之后 , 弹栈 , 栈帧销毁

        堆内存 : 保存类对象和成员变量及成员方法

1 编码 : 程序员通过java语言 , 编写java程序

2 编译 : 把java文件编译成class文件

3 运行 , 运行时 JVM开机,将所运行的类载入内存空间中的静态区

        3.1 加载完成后,JVM会自动调用该类的main方法(只要是方法调用,就会在栈内存中开辟栈帧并压栈)

        3.2 如果main方法中,有别的方法调用

                3.2.1 如果调用的是其他类中的方法,则先把对应类加载到静态区,然后再栈内存中开辟栈帧

                3.2.2 如果调用的是当前类中的方法,则直接在栈内存开辟栈帧

        3.3 如果被调用的方法中,还有其他方法调用,则继续开辟栈帧压栈,一直到栈顶元素,执行完成,弹栈,返回上一个栈帧继续执行

        3.4 直到main栈帧弹栈,则整个程序生命周期终止

        public static void main(String[] args) {

                m1();

                System.out.println("main执行了");

        }

        public static void m1() {

                m2();

                System.out.println("m1执行了");

        }

        public static void m2() {

                m3();

                System.out.println("m2执行了");

        }

        public static void m3() {

                System.out.println("m3执行了");

        }

3. 递归

3.1. 概述和基本应用

递归和迭代(循环)是等价的

循环可以做的,递归也能做,但是递归能做的,循环不一定能做

递归需要频繁压栈弹栈,比较消耗内存,并且效率较低,所以循环能完成的,就不要使用递归

比如 树状结构,目录遍历等 都需要使用递归完成

递归 :

        直接递归 : 方法中调用当前方法(自己调用自己)

        间接递归 : 两个方法相互调用

        public static void main(String[] args) {

                m1();

        }

// 直接递归

        public static void m1(){

// 注意 递归 也有符合 循环三要素

// 初始值,终止条件,步长,否则会死循环

// Exception in thread "main" java.lang.StackOverflowError

// 因为一直压栈,不会弹栈,导致栈内存移出

        m1();

        }

// 间接递归

        public static void m2(){

                m3();

        }

        public static void m3(){

                m2();

        }

public static int m1(int m) {

        if (m == 1) {

                return 1;

       }

        return m + m1(m - 1);

}

3.2. 斐波那契数列

斐波那契数列 :

前两位为1, 后面每位的值都等于前两位的和

1 1 2 3 5 8 13 21 34 55 89

        public static void main(String[] args) {

                int result = test(21);

                System.out.println(result);

        }

// 计算 第N位的值 是多少

        public static int test(int n) {

                if (n == 1 || n == 2) {

                        return 1;

        }

        return test(n - 1) + test(n - 2);

}

        public static void test2(int n){

// 默认表示第一位(还表示当前位的前两位)

        long a = 1;

// 默认表示第二位(还表示当前位的前一位)

        long b = 1;

        long c = 1;// 表示当前位

        if (n == 1 || n == 2) {

                System.out.println(1);

                return;

        }

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

                c = a+b;

                a = b;

                b = c;

        }

                System.out.println(c);

}