(JavaSE)第四章--方法执行时内存变化及重载递归——下_java中重载内存变化大吗

于 2024-04-21 18:01:08 发布
阅读量815 收藏 21
点赞数 29
分类专栏： 2024年程序员学习 文章标签： java 服务器 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84537498/article/details/138040266
版权

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：xhs1999xhs （备注Java）
img

正文

文章目录

一、方法执行时内存的变化

1. JVM内存结构

JVM中主要的三块内存空间：栈、堆、方法区。当然，还有其他的。

在这里插入图片描述

2. 栈数据结构

栈存放的是局部变量

在这里插入图片描述

3. 研究方法执行时内存的变化(实例)

public class Main1 {
    public static void m1(int i) {
        System.out.println("m1 begin");
        m2(i);
        System.out.println("m1 over");
    }
    public static void m2(int i) {
        System.out.println("m2 begin");
        System.out.println(i);
        System.out.println("m2 over");
    }
    public static void main(String[] args) {
        System.out.println("main begin");
        int a = 100;
        m1(a);
        System.out.println("main over");
    }
}

第一步：

在这里插入图片描述

第二步：

> 此时 m1 方法为栈顶元素，具有活跃权，i 接收了 main 方法中 a 赋给的值，直到执行完 m2(i) 这条语句，m2方法压栈，m1方法此时不为栈顶元素，失去活跃权，停下。

在这里插入图片描述

第三步：

> 此时 m2 方法为栈顶元素，具有活跃权，直到执行完 “m2 begin” 这条语句，m2方法执行结束，并且销毁数据(弹栈)。此时 m1 为栈顶元素。

在这里插入图片描述

第四步：

m1弹栈后，此时 main方法为栈顶元素，具有活跃权。

在这里插入图片描述

第五步：

在这里插入图片描述
总结来说其步骤如下：
在这里插入图片描述

二、方法重载

1. 体验方法重载

我们先来看看以下代码：

public class Main2 {
    public static int addInt(int x, int y) {
        return x + y;
    }
    public static double addDouble(double x, double y) {
        return x + y;
    }
    public static double addIntDouble(int x, double y) {
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        double c = 10.5;
        double d = 5.0;
        int ret1 = addInt(a, b);
        double ret2 = addDouble(c, d);
        double ret3 = addIntDouble(a, c);
        System.out.println(ret1);
        System.out.println(ret2);
        System.out.println(ret3);
    }
}

在这里插入图片描述

上述代码确实可以解决问题，但不友好的地方是：需要提供许多不同的方法名，而取名字本来就是让人头疼的事情。

我们再来看看以下代码：

public class Main2 {
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(int x, double y) {
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        double c = 10.5;
        double d = 5.0;
        int ret1 = add(a, b);
        double ret2 = add(c, d);
        double ret3 = add(a, c);
        System.out.println(ret1);
        System.out.println(ret2);
        System.out.println(ret3);
    }
}

我们可以看到他们的方法名是相同的，这样就叫做重载。

2. 重载的定义和规则

  1. 在自然语言中，一个词语如果有多重含义，那么就说该词语被重载了，具体代表什么含义需要结合具体的场景。
  2. 例如：在现实扶老奶奶过马路，她说你是个好人，而当你对喜欢的女生表白是，她说你是个 “好人”。很明显这个 “好人” 的含义是不同的。
  3. 在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

使用方法重载的规则:

1. 方法名必须相同

如以下，计算整型和浮点型的方法名都为 add

public class Main2 {
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        double c = 10.5;
        double d = 5.0;
        System.out.println(add(a, b));
        System.out.println(add(c, d));
    }
}

2. 参数列表必须不同( 参数的个数不同 或 参数的类型不同 或 参数的顺序不同)

参数的个数不同

我们可以看到其参数的个数不想同，一个为 2 个参数，一个为 3 个参数。

public class Main2 {
    public static int add(int a, int b) {
        return a + b;
    }
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        int ret1 = add(a, b);
        int ret2 = add(a, b, c);
        System.out.println(ret1);
        System.out.println(ret2);
    }
}

参数的类型不同
可以看到其参数类型不同，一个add为两个整型参数，一个add为一个整型，一个浮点型参数。

public class Main2 {
    public static int add(int a, int b) {
        return a + b;
    }
    public static double add(int a, double c) {
        return a + c;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        double c = 30.5;
        int ret1 = add(a, b);
        double ret2 = add(a, c);
        System.out.println(ret1);
        System.out.println(ret2);
    }
}

参数的顺序不同
我们可以看到其顺序不同，一个为 add(double a , int a) {} ，一个为 add(int a, double a) {}

public class Main2 {
    public static double add(double b, int a) {
        return a + b;
    }
    public static double add(int a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        int a = 10;
        double b = 0.5;
        double ret1 = add(b, a);
        double ret2 = add(a, b);
        System.out.println(ret1);
        System.out.println(ret2);
    }
}

3.与返回值类型无关
方法的重载与返回值类型无关。

3. 方法签名

  1. 在同一个作用域中不能定义两个相同名称的标识符。
    比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？
  2. 方法签名即：经过编译器编译修改过之后方法最终的名字。
    具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
public class Main2 {
    public static double add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static void main(String[] args) {
        System.out.println(add(5, 10));
        System.out.println(add(2.5, 3.5));
    }
}

上述代码经过编译之后，然后使用JDK自带的javap反汇编工具查看，具体操作：

  1. 先对工程进行编译生成.class字节码文件
  2. 在控制台中进入到要查看的.class所在的目录
  3. 在DOS命令窗口输入：javap -v 字节码文件名字即可

在这里插入图片描述在这里插入图片描述

4. 小练习

在同一个类中定义多个方法：要求不仅可以求两个整数的最大值，还可以求两个小数的最大值，以及两个小数和一个整数的大小关系

public class Test4 {
    public static int max(int n, int m) {
        return Math.max(n, m);
    }
    public static double max(double n, double m) {
        return Math.max(n, m);
    }
    public static void max(int n, double m, double d) {
        double max = (n > m && n > d) ? n : Math.max(m, d);
        double min = (n < m && n < d) ? n : Math.min(m, d);
        double mid = (n + m + d) - (max + min);
        System.out.println(max + ">" + mid + ">" + min);
    }
    public static void main(String[] args) {
        int ret = max(10, 20);
        System.out.println(ret);
        double sum = max(10.5, 10.4);
        System.out.println(sum);
        max(10, 10.5,10.4);
    }
}

在这里插入图片描述

三、递归

1. 递归的定义及规则

  1. 方法自己调用自己叫做递归。
  2. 递归的两个必要条件：
    存在限制条件，当满足这个限制条件之后，递归便不再继续。
    每次递归调用之后越来越接近这个条件。
  3. 递归，顾名思义，分为递和归。
  4. 如一个故事：
    从前有坐山，山上有座庙，庙里有个老和尚给小和尚将故事，讲的就是：
    "从前有座山，山上有座庙，庙里有个老和尚给小和尚讲故事，讲的就是:
    “从前有座山，山上有座庙…”
    “从前有座山……”
    "
    这个限制条件就是这个老和尚饿了或者寿命到尽头了，每次重复一遍离这个限制条件越来越近。

2. 练习理解递归

1. 写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19。

import java.util.Scanner;
public class Main3 {
    public static int test(int n) {
    if (n > 9) {
        return (n % 10) + test(n / 10);
    }
    return n % 10;
}
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        int ret = test(n);
        System.out.println(ret);
    }
}
  1. 在以上代码中 n > 9为限制条件。
  2. n / 10 使得该数越来越接近该限制条件。

如我们输入1234：

在这里插入图片描述递归结果我们可以看到结果为10。

  1. 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) （递归）
import java.util.Scanner;

public class Main4 {
    public static void prints(int n) {
        if (n > 9) {
            prints(n / 10);
        }
        System.out.print( n % 10 + " ");
    }
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        prints(n);
    }
}

在这里插入图片描述
在这里插入图片描述

  1. 递归求 N 的阶乘
import java.util.Scanner;

public class Test2 {
    public static int fun(int n) {
        if (n != 1) {
            return n \* fun(n-1);
        }
        return 1;
    }
    public static void main(String[] args) {
        Scanner num = new Scanner(System.in);
        int n = num.nextInt();
        int ret = fun(n);
        System.out.println(ret);
    }
}

在这里插入图片描述在这里插入图片描述
好了，本章节就到这里结束了，因博主能力有限，如发现错误请及时提出，谢谢各位大佬 ^_$

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

image

上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

image

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：xhs1999xhs（备注Java）
img

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
a4c4ea98e4e955e4a22c951.png)
好了，本章节就到这里结束了，因博主能力有限，如发现错误请及时提出，谢谢各位大佬 ^_$

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

[外链图片转存中…(img-a8LZMRcB-1713693615809)]

上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

[外链图片转存中…(img-bqDlIhhz-1713693615809)]

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：xhs1999xhs（备注Java）
[外链图片转存中…(img-VNrg53L4-1713693615810)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84537498
关注
专栏目录
递归调用方法时栈内存是如何变化的？（使用内存图演示递归调用过程）
liaowenxiong的博客
06-07 1107
文章目录什么是栈内存演示方法递归调用过程 什么是栈内存 在学习递归实现原理之前，我们先了解一下栈内存。 栈内存是计算机中的一种数据存储方式，是 Java 进程启动时候在内存中开辟的存储空间。 栈内存的利用方式遵循 LIFO(后迚先出)原则 Java 所有局部变量都在栈中分配(压入)，方法的参数也是局部变量，局部变量在离开作用域时候回收，就是从栈中弹出(删除)。 Java 中所有的局部变量都是在栈内存中分配的(包括方法中声明的变量、方法的参数)。 Java 方法调用使用栈实现, 递归调用就是栈实现的。递归
JavaSE(四)--方法和递归
weixin_49349430的博客
11-22 136
方法 1.方法作用: 减少代码,实现代码复用;方便后期维护. 2.方法 实现特定功能的一段独立代码块. 3.方法的声明 3.1:语法 访问修饰符 扩展修饰符[static/abstract/final] 返回值类型 方法名 (数据类型1 参数1,数据类型2 参数2...){ 方法体(代码块); return 结果; } 3.2:访问修饰符 [public/protected/default/private],一般用public修饰符. 作用限制方法 使用权限. 3.3:返回值类型 方法
(JavaSE)第四章--方法执行时内存变化及重载递归——下
Autonmy_的博客
03-24 996
关于方法的内容
Day-5
hhdxxy的博客
09-29 113
方法重载，内存划分，递归 1 方法 1.1方法重载 方法重载：方法名字相同，参数列表不同 参数列表不同分成两种：1. 类型不同 2.个数不同 相同功能，相同名字，通过不同的参数区分，比较美观，容易记忆，相同功能只需要记住一个方法即可 1.2 内存划分 程序：可以执行的文件，是一对命令的集合，是静态概念，储存在硬盘里 进程：正在执行中的程序，是动态概念，保存在运行内存之中，会按照该程序的设计在内存中一步步执行 运行中的程序 也就是指载入到内存中的可执行文件,操作系统会开启一...
JVM内存区域：递归JVM指令分析
学亮编程手记
05-03 472
Java java中的内存分析
weixin_40123451的博客
07-26 250
1、类的实例化内存分析 1> 成员变量中的实例变量只在堆内存中存储，只能通过对象(实例)去访问。不能通过类名去访问 2> 带static的变量称为静态成员变量 2、方法调用内存分析 1> 方法体中的局部变量只在栈内存中存储 2> 方法调用时，入栈。return关键字就是pop(出栈)，方法结束 3、方法的递归调用内存分析 1> 递归调用的本质就是入栈执行，递归结束出栈 2> 递归方法中必须存在递归...
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
最新发布
03-03
对于Java开发者来说，掌握JavaSE是必备技能，也是面试中经常被考察的知识点。下面我们将深入探讨JavaSE中的一些常见面试题及其解答。 1. **Java基础** - **对象与类**：Java是一种面向对象的语言，理解类和对象的...
JavaSE--思维导图解析
07-26
JavaSE 是 Java Standard Edition 的缩写，指的是 Java 语言的标准版。下面是 JavaSE 的思维导图解析： 语言特性 * 面向对象（OOP 语言） * 高性能 * 分布式 * 健壮性 Java 基础 * `main` 方法：`public static ...
Java的方法定义(有参方法、无参方法、有返回值的方法、方法重载、递归)
Learn to value time
12-16 795
1. 何谓方法 什么是方法？ 答：语句的集合,是一段用来完成特定功能的代码，方法在程序中被创建,在其他地方被引用 为什么使用方法? 答：方法最大的好处就是可以很好地复用一个代码块，当代码量大的时候就能感受到了 方法应该写在哪？ 答：方法应该写在类括号里，一个方法中不可以嵌套另一个方法，但可以调用其他方法 设计方法原则：方法本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法为的原子性，就是一个方法只完成一个功能,这样利于我们扩展 2.方法的定义及调用 方法包含
Java-----反射【内存分析、根据反射创建各种对象、普通方法调用与反射的对比速度】
AMT_MUZI的博客
04-27 581
Java内存分析 了解：类的加载过程 当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。 类的加载与ClassLoader的理解 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法其的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。 验证：确保加载的类信息符合JVM规范，没有安全方面的问题 准备：正式为类变量（static）分配内存并设置类
java中方法重载内存分析
10-15
本例是java中一个方法重载的程序，并通过这个具体程序来分析其中的内存分配过程，适合初学java，对java中内存分配不熟悉的人学习。
关于java递归调用内存泄漏
优雅的IT之道
04-15 2997
看两段代码：import java.util.ArrayList;   import java.util.List;     public class TailRecursionTest {       public static void main(String[] args) {           TailRecursionTest t = new TailRecursionTest()
java：方法的内存分析，重载和递归
weixin_44695358的博客
06-28 198
方法执行中的内存分析 在代码行中（editplus中）如果是红色字体的，那就是Sun公司提供的类库中自带的类（在rt.jar压缩包里） 代码在加载的时候也会被加载到方法区内存里 比如System，String 自定义的类是黑色，是标志符（类名都是标志符） 方法在调用的时候参数传递的是变量保存的值。 栈内存中主要存储局部变量 public class MethodTest01 { public static void main(String[]args){ int a=10; int b=20;
JAVA入门—重谈方法
LiLi的博客
11-02 300
关于方法，先不说方法是什么，先来看没有使用方法写的代码所存在的问题 以下代码都是完成两int类型数据的求和，相同的代码写了三遍（只不过每次参与运算的数据不同），代码没有得到重复利用 应该在Java中存在一种机制： 实现某个功能的代码只要写一遍 要使用这个功能，只需要把具体的数据传递给它 这个功能完成后返回一个最终结果 这样一来，代码就能得到重复利用，提高代码复用性【这就是“方法”】 public class MethodTest01{ public static void main(String[]
方法重写与方法重载的区别详解
chunlutang0555的博客
05-24 482
@[TOC] 1、方法重写（Override） 概念： 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！ 好处： 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。 注意： 重写方法不能抛出新...
深度递归的 内存 优化 方法
凯凯的博客
09-11 1300
问题: 递归: n! =123*(n-1)*n; 3! 每一次递归 栈都会分配内存,如果次数太多 栈的内存不够了 就会报错. 解决方法 扩大栈 的容量 修改Xss 但不是长久之计 c 语言 –尾调用 最后一次 在执行运算 阻止递归一次就分配一次内存 java如何?在这里插入图片描述 实现 首先我们实现了一个尾调用的接口，方便大家使用： // 尾调用的接口，定义了是否完成，...
java的递归实现原理
李卫康的博客
08-10 7830
打印5的阶乘 5! 1.普通方法实现 package cn.itcast.digui; public class DiGuiDemo { public static void main(String[] args) { int temp=1;//初始值是1 for(int i=2;i<=5;i++){ temp*=i;//每遍历一次就乘以 } System.out.p
关于java递归调用内存泄露
cj6585256的专栏
03-08 1176
看两段代码： import java.util.ArrayList;    import java.util.List;       public class TailRecursionTest {        public static void main(String[] args) {            TailRecursionTest t = new TailRec
java 递归速度和内存
阿萨的专栏
09-11 2997
通常来说，java递归函数运行一般比循环函数慢，有时候甚至是一倍的差距，看下面的代码 public class RecursiveCall { public static void main(String[] args) { int total = 0; int first = 100; for (int x = 0; x &lt; f...
"JavaSE基础语法与常用工具总结
JavaSE 五万字总结.pdf包含了Java基础语法，类型转换，运算符，流程控制，循环，Random，数组，方法，方法重载，递归，二进制，类和对象，成员变量局和部变量，封装，构造方法，String，集合，继承，GIT，抽象类，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值