精华内容
下载资源
问答
  • 主要介绍了 Java 值传递和引用传递详解及实例代码的相关资料,需要的朋友可以参考下
  • java 中没有引用传递,都是值传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • 值传递和引用传递

    2020-12-23 01:08:15
    1.值传递:只要是基本数据类型传递就是值传递,传递的就是值 package arrayDemo; public class Demo1 { public static void main(String[] args) { int b =20; change(b);// 实参 实际上的参数 System.out.println...
  • 一个实例让你明白什么是值传递和引用传递的!
  • 主要介绍了java通过实例了解值传递和引用传递,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JavaScript有5种基本的数据类型,分别是:布尔、null、undefined、String和Number。这篇文章主要介绍了JavaScript的值传递和引用传递,需要的朋友可以参考下
  • 主要为大家详细介绍了Java值传递和引用传递,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 另一方面,值传递由于形参实参内存地址不一样,有些功能并不能实现(swap()),因此,除了极为简单的函数会使用值传递外,大多数会采用引用传递。而对于指针传递,则在涉及数组的情况下使用较多,因为指针本身会给...
  • 当一个变量为一个参数传入方法内部的时候,会有两种不同的传递方式:值传递和引用传递。  值传递的特点:不管方法内部对传进去的参数作任何改变,也不会影响方法外部的变量的值  引用传递的特点:方法内部对传...
  • 值传递和引用传递的区别

    千次阅读 2018-07-19 21:13:00
    值传递是指基本数据类型在方法中的传递,引用传递是指引用数据类型在方法中的传递,举例来说,如下图程序代码运行所示: 注:int属于基本数据类型,因此在方法中进行传递和引用时,并不会改变该变量的数值 而arr...

    值传递是指基本数据类型在方法中的传递,引用传递是指引用数据类型在方法中的传递,举例来说,如下图程序代码运行所示:

    注:int属于基本数据类型,因此在方法中进行传递和引用时,并不会改变该变量的数值

    而arr属于数组,是引用数据类型,因此在方法引用时,实际传递的是该数组在堆内存中的物理内存地址,在方法中对该数组进行操作,则会影响到该数组内部的数值,会发生改变

    原因:

    在java中,基本数据类型作为参数传递的时候叫做值传递,传的是值本身,

                       值传递:值在该方法中改变属于局部变量改变

                       当出了该方法就没有作用了(方法中的传递的基本数据类型就属于局部变量)

    在java中,方法的传参,引用数据类型,传的是物理内存地址值,当方法中对数组内部的数值进行改变时,

                       并未改变该数组的物理内存地址,所以当返回到主方法中,数组还是指向原来的地址。

                      当传入arr数组在内存中的地址值后,堆内存中的连续地址发生改变,可以影响数组整体

    特例:String /基本数据类型包装类,虽然都是引用数据类型,但是在发生传参的时候,它们传的是值

    注:引用数据类型可以参考c语言中的指针来帮助记忆

     

    展开全文
  • Java值传递和引用传递

    千次阅读 2018-08-20 10:35:24
    通过这两天的实习面试,发现自己的基础实在烂的不行,先不打算投简历了,安安心心的在家学了几个月,把最基本的东西全部搞懂再说。之前看到别人也在写类似的模块,觉得挺好的,因此我打算每天(也有可能几...值传递 ...

    通过这两天的实习面试,发现自己的基础实在烂的不行,先不打算投简历了,安安心心的在家学了几个月,把最基本的东西全部搞懂再说。之前看到别人也在写类似的模块,觉得挺好的,因此我打算每天(也有可能几天…)整理一个常考的知识点,帮助自己整理和巩固,加油把

    一、前言

    先分清楚两个概念

    • 按值传递:方法接收的是调用者提供的值
    • 按引用传递:方法接收的是调用者提供的变量地址

    《Java 核心技术》中说:“Java程序设计语言总是采用按值来调用的,即,方法得到的是所有参数值的一个拷贝。因为传递过来的相当于是一个副本,因此方法只能改变这个副本所对应的值或者对象。

    二、分析

    2.1 将基本数据类型作为参数传递

    我们可以直接看一个值传递的例子

    public void swap(int x, int y) {
    	int temp = x;
    	x = y;
    	y = temp;
    }
    	
    @Test
    void testObject() {
    	int a = 100;
    	int b = 200;
    	swap(100, 200);
    	System.out.println("a: " + a);
    	System.out.println("b: " + b);
    }
    
    //输出
    a: 100
    b: 200
    

    可见,a 和 b 的值在经过“所谓的”交换函数之后,并没能把值交互。这是为什么呢?

    这就是因为java是值传递的。也就是说,我们在调用一个需要传递参数的函数时,传递给函数的参数并不是我们传进去的参数本身,而是它的副本。

    以这个例子来说,当我们调用 swap 这个函数时,并不是传入的真正的 a 和 b 这两个参数,而是他们俩的复制品,比如我们定义这两个复制品为 x 和 y,此时 x 会指向另一个 100,y 会指向另一个 200。之后在方法 swap 中的所有操作,其实都是基于这两个复制出来的变量 x 和 y 进行着的。尽管 x 和 y 的值确实交换了,但是他们值的改变并不能影响到 a 和 b。

    再来看一个例子:

    void foo(int val) {
    	val = 100;
    }
    
    void foo1(String text) {
    	text = "win";
    }
    
    @Test
    public void print() {
    	int val = 200;
    	foo(val);
    	System.out.println(val);
    	
    	String text = "hello";
    	foo1(text);
    	System.out.println(text);
    }
    

    无可厚非,输出分别是 200 和 hello。可以用图片来描述一下流程

    首先,在调用方法之前,会先创建一个形参 val

    当调用 foo 函数的时候,实参 val 将自身的值拷贝一份,将拷贝的副本传给形参
    这里写图片描述

    当执行函数中的语句时,其实都是对拷贝的那个参数,即形参 val 进行赋值,可以看到,我们将他直接变为了 100,而实际的参数 val,还是原来的 200
    这里写图片描述

    2.2 将对象引用作为参数传递

    顾名思义,就是方法的参数是一个类的引用

    class People {
    	int age;
    }
    
    @Test
    void testObject() {
    	People p1 = new People();
    	People p2 = new People();
    	p1.age = 10;
    	p2.age = 15;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    	
    	p1 = p2;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    	
    	p1.age = 30;
    	System.out.println("p1.age: " + p1.age + " p2.age: " + p2.age);
    }
    
    //输出
    p1.age: 10 p2.age: 15
    p1.age: 15 p2.age: 15
    p1.age: 30 p2.age: 30
    

    通过图示我们可以分析一下

    首先在栈中建立两个引用 p1 和 p2,分别指向堆中 new 出来的对象
    这里写图片描述

    执行 p1=p2 这个语句,把栈中 p1 指向 p2 在堆中指向的位置,即第二个 People 对象,此时 p1 和 p2 都指向了堆中第二个 People 对象
    这里写图片描述

    执行 p1.age=30 这个语句,即把第二个 People 对象的 age 属性变为30,由于 p1 和 p2 都指向这个对象,因此 p1 和 p2 的 age 属性都是 30
    这里写图片描述

    我们可以再来看一个例子

    void foo(StringBuffer stringBuffer) {
    	stringBuffer.append("world");
    }
    
    @Test
    void bufferTest2() {
    	StringBuffer sb = new StringBuffer("hello");
    	foo(sb);
    	System.out.println(sb);
    }
    

    输出结果是 helloworld,表明原来的值已被改变。照例,我们画个图

    一开始,栈中的 StringBuffer 引用指向堆中的 StringBuffer 对象,该对象里面的值为 “hello”
    这里写图片描述

    当使用方法时,形参会先产生一个 StringBuffer 引用 stringBuffer,然后指向堆中的对象
    这里写图片描述

    然后调用方法,append 方法直接改变的就是原来 String 的值。可以看到,此时堆中 StringBuffer 对象中的值已经改变,此时两个引用 sb 和 stringBuffer 都指向同一个对象
    这里写图片描述

    我们再来看另一个例子

    void foo1(StringBuffer stringBuffer) {
    	stringBuffer = new StringBuffer("world");
    }
    
    @Test
    void bufferTest2() {
    	StringBuffer sb = new StringBuffer("hello");
    	
    	foo1(sb);
    	System.out.println(sb);
    }
    

    此时输出的值没有改变,还是 “hello”。这是为什么呢?

    当调用 fool 方法的时候,实际在栈中又新创建了一个 StringBuffer 的引用 stringBuffer,这个引用重新指向了一个新的 StringBuffer 对象。
    这里写图片描述

    所以即使当执行方法之后,输出 sb,依旧还是原来的 sb 指向的对象中的值,即 “hello”

    2.3 值传递和引用传递

    由于 C++ 有值传递和引用传递两种方式,那么 Java 呢?实际上,Java 是采用的值传递

    class Employee {
        int x;
    
        Employee(int a) {
            this.x = a;
        }
    }
    
    public class ObjectTest2 {
        static void swap(Employee x, Employee y){
            Employee temp = x;
            x = y;
            y = temp;
        }
    
        public static void main(String[] args) {
            Employee employee = new Employee(100);
            Employee employee1 = new Employee(200);
            System.out.println("交换前:" + employee.x + " " + employee1.x);
            swap(employee, employee1);
            System.out.println("交换后:" + employee.x + " " + employee1.x);
        }
    }
    

    结果是:

    交换前:100 200
    交换后:100 200
    

    这个例子很明显,如果 Java 是引用传递,那么在调用完那个方法之后,应该可以实现数据的交换,但实际上,并没有交换。

    可以看到,两个对象引用传到方法之后,拷贝出了两个对象引用 x, y,x 指向 的是第一个 Employee 对象,y指向的是第二个。然后 swap() 方法中交换的其实仅仅是拷贝所指向的地址

    最后,方法结束,x 和 y 也被回收,而最原始的两个对象引用 employee 和 employee1 还是指向之前的两个对象

    那为什么不是引用传递呢?

    其实可以联想一下 C++ 是如何进行引用传递的

    void swap(int *p1, int *p2){
        int *temp;
        temp = p1;
        p1 = p2;
        p2 = temp;
    }
    

    可以看到,同样也是传入两个参数的地址,然后直接改变两个参数所在的内存地址。这个时候从内存中取出对应的数值应该就是相反的值了

    然后我们再看 Java,同样传入的是地址,那么他是如何实现的呢?传入一个引用,拷贝一份,再传入一个,再拷贝一个,之后的事情就很简单了,直接对拷贝的引用所指向的对象进行操作。因此,他和 C++ 的引用传递是是不一样的。

    因此,Java 本至上还是值传递

    结论
    • 一个方法不能修改一个基本数据类型的参数
    • 一个方法可以改变一个对象参数的状态
    • 一个方法不能让对象参数引用一个新的对象
    展开全文
  • java中的值传递和引用传递的区别?

    千次阅读 2018-11-29 21:04:51
    1.值传递概念:值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。 实例: public class Main { public static void main(String[] args) { int ...

    1.值传递概念:值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。

    实例:

    public class Main {
        public static void main(String[] args) {
            int num  = 10;//实际参数
            test(num);
            System.out.println(num);//num的值没有被改变,任然为10;
        }
        //测试值传递的方法
        public static void test(int num){
            num = num + 10;
        }
    }

    2.引用传递:所谓引用传递是指在调用函数时将实际参数的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    实例:

    public class Main {
        public static void main(String[] args) {
            Student student = new Student("zhangsan",20);//实际参数
            test(student);
            System.out.println(student);//结果为Student{name='lisi', age=20}
        }
        //测试引用传递的方法
        public static void test(Student student){
            student.setName("lisi");
        }
    }

    总结:值传递和引用传递都是传递的栈空间中的内容,因为栈空间存的是基本数据类型的值(所以表现为值传递),而栈空间存的引用类型的地址(所以表现为引用传递)。

    展开全文
  • 这一次,让你彻底明白Java的值传递和引用传递

    万次阅读 多人点赞 2018-10-29 08:39:00
    本文旨在用最通俗的语言讲述最枯燥的基本知识学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运...

    本文旨在用最通俗的语言讲述最枯燥的基本知识

    学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运用却解释不出原理,而且坊间讨论的话题又是充满争议:有的论坛帖子说Java只有值传递,有的博客说两者皆有;这让人有点摸不着头脑,下面我们就这个话题做一些探讨,对书籍、对论坛博客的说法,做一次考证,以得出信得过的答案。

    其实,对于值传递和引用传递的语法和运用,百度一下,就能出来可观的解释和例子数目,或许你看一下例子好像就懂,但是当你参加面试,做一道这个知识点的笔试题时感觉自己会,胸有成熟的写了答案,却发现是错的,或者是你根本不会做。

    是什么原因?

    那是因为你对知识点没有了解透彻,只知道其皮毛。要熟读一个语法很简单,要理解一行代码也不难,但是能把学过的知识融会贯通,串联起来理解,那就是非常难了,在此,关于值传递和引用传递,小编会从以前学过的基础知识开始,从内存模型开始,一步步的引出值传递和引用传递的本质原理,故篇幅较长,知识点较多,望读者多有包涵。

    1. 形参与实参

    我们先来重温一组语法:

    1. 形参:方法被调用时需要传递进来的参数,如:func(int a)中的a,它只有在func被调用期间a才有意义,也就是会被分配内存空间,在方法func执行完成后,a就会被销毁释放空间,也就是不存在了

    2. 实参:方法被调用时是传入的实际值,它在方法被调用前就已经被初始化并且在方法被调用时传入。

    举个栗子:

    1public static void func(int a){
    2 a=20;
    3 System.out.println(a);
    4}
    5public static void main(String[] args) {
    6 int a=10;//变量
    7 func(a);
    8}

    例子中
    int a=10;中的a在被调用之前就已经创建并初始化,在调用func方法时,他被当做参数传入,所以这个a是实参。
    而func(int a)中的a只有在func被调用时它的生命周期才开始,而在func调用结束之后,它也随之被JVM释放掉,,所以这个a是形参。

    2. Java的数据类型

    所谓数据类型,是编程语言中对内存的一种抽象表达方式,我们知道程序是由代码文件和静态资源组成,在程序被运行前,这些代码存在在硬盘里,程序开始运行,这些代码会被转成计算机能识别的内容放到内存中被执行。
    因此

    数据类型实质上是用来定义编程语言中相同类型的数据的存储形式,也就是决定了如何将代表这些值的位存储到计算机的内存中。

    所以,数据在内存中的存储,是根据数据类型来划定存储形式和存储位置的。
    那么
    Java的数据类型有哪些?

    1. 基本类型:编程语言中内置的最小粒度的数据类型。它包括四大类八种类型:

    4种整数类型:byte、short、int、long
    2种浮点数类型:float、double
    1种字符类型:char
    1种布尔类型:boolean

    1. 引用类型:引用也叫句柄,引用类型,是编程语言中定义的在句柄中存放着实际内容所在地址的地址值的一种数据形式。它主要包括:


    接口
    数组

    有了数据类型,JVM对程序数据的管理就规范化了,不同的数据类型,它的存储形式和位置是不一样的,要想知道JVM是怎么存储各种类型的数据,就得先了解JVM的内存划分以及每部分的职能。

    3.JVM内存的划分及职能

    Java语言本身是不能操作内存的,它的一切都是交给JVM来管理和控制的,因此Java内存区域的划分也就是JVM的区域划分,在说JVM的内存划分之前,我们先来看一下Java程序的执行过程,如下图:

    640?wx_fmt=png

    有图可以看出:Java代码被编译器编译成字节码之后,JVM开辟一片内存空间(也叫运行时数据区),通过类加载器加到到运行时数据区来存储程序执行期间需要用到的数据和相关信息,在这个数据区中,它由以下几部分组成:


    1. 虚拟机栈
    2. 堆
    3. 程序计数器
    4. 方法区
    5. 本地方法栈

    我们接着来了解一下每部分的原理以及具体用来存储程序执行过程中的哪些数据。


    1. 虚拟机栈

    虚拟机栈是Java方法执行的内存模型,栈中存放着栈帧,每个栈帧分别对应一个被调用的方法,方法的调用过程对应栈帧在虚拟机中入栈到出栈的过程。

    栈是线程私有的,也就是线程之间的栈是隔离的;当程序中某个线程开始执行一个方法时就会相应的创建一个栈帧并且入栈(位于栈顶),在方法结束后,栈帧出栈。

    下图表示了一个Java栈的模型以及栈帧的组成:

    640?wx_fmt=png

    栈帧:是用于支持虚拟机进行方法调用和方法执行的数据结构,它是虚拟机运行时数据区中的虚拟机栈的栈元素。


    每个栈帧中包括:

    1. 局部变量表:用来存储方法中的局部变量(非静态变量、函数形参)。当变量为基本数据类型时,直接存储值,当变量为引用类型时,存储的是指向具体对象的引用。

    2. 操作数栈:Java虚拟机的解释执行引擎被称为"基于栈的执行引擎",其中所指的栈就是指操作数栈。

    3. 指向运行时常量池的引用:存储程序执行时可能用到常量的引用。

    4. 方法返回地址:存储方法执行完成后的返回地址。


    2. 堆:

    堆是用来存储对象本身和数组的,在JVM中只有一个堆,因此,堆是被所有线程共享的。


    3. 方法区:

    方法区是一块所有线程共享的内存逻辑区域,在JVM中只有一个方法区,用来存储一些线程可共享的内容,它是线程安全的,多个线程同时访问方法区中同一个内容时,只能有一个线程装载该数据,其它线程只能等待。

    方法区可存储的内容有:类的全路径名、类的直接超类的权全限定名、类的访问修饰符、类的类型(类或接口)、类的直接接口全限定名的有序列表、常量池(字段,方法信息,静态变量,类型引用(class))等。


    4. 本地方法栈:

    本地方法栈的功能和虚拟机栈是基本一致的,并且也是线程私有的,它们的区别在于虚拟机栈是为执行Java方法服务的,而本地方法栈是为执行本地方法服务的。

    有人会疑惑:什么是本地方法?为什么Java还要调用本地方法?


    5. 程序计数器:

    线程私有的。
    记录着当前线程所执行的字节码的行号指示器,在程序运行过程中,字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、异常处理、线程恢复等基础功能都需要依赖计数器完成。


    4. 数据如何在内存中存储?

    从上面程序运行图我们可以看到,JVM在程序运行时的内存分配有三个地方:

    • 静态方法区

    • 常量区

    相应地,每个存储区域都有自己的内存分配策略:

    • 堆式:

    • 栈式

    • 静态

    我们已经知道:Java中的数据类型有基本数据类型和引用数据类型,那么这些数据的存储都使用哪一种策略呢?
    这里要分以下的情况进行探究:

    1. 基本数据类型的存储:

    • A. 基本数据类型的局部变量

    • B. 基本数据类型的成员变量

    • C. 基本数据类型的静态变量

    2. 引用数据类型的存储


    1. 基本数据类型的存储


    我们分别来研究一下:

    A.基本数据类型的局部变量
    1. 定义基本数据类型的局部变量以及数据都是直接存储在内存中的栈上,也就是前面说到的“虚拟机栈”,数据本身的值就是存储在栈空间里面。

      640?wx_fmt=png


      如上图,在方法内定义的变量直接存储在栈中,如

    1int age=50;
    2int weight=50;
    3int grade=6;

    当我们写“int age=50;”,其实是分为两步的:

    1int age;//定义变量
    2age=50;//赋值

    首先JVM创建一个名为age的变量,存于局部变量表中,然后去栈中查找是否存在有字面量值为50的内容,如果有就直接把age指向这个地址,如果没有,JVM会在栈中开辟一块空间来存储“50”这个内容,并且把age指向这个地址。因此我们可以知道:
    我们声明并初始化基本数据类型的局部变量时,变量名以及字面量值都是存储在栈中,而且是真实的内容。

    我们再来看“int weight=50;”,按照刚才的思路:字面量为50的内容在栈中已经存在,因此weight是直接指向这个地址的。由此可见:栈中的数据在当前线程下是共享的

    那么如果再执行下面的代码呢?

    1weight=40

    当代码中重新给weight变量进行赋值时,JVM会去栈中寻找字面量为40的内容,发现没有,就会开辟一块内存空间存储40这个内容,并且把weight指向这个地址。由此可知:

    基本数据类型的数据本身是不会改变的,当局部变量重新赋值时,并不是在内存中改变字面量内容,而是重新在栈中寻找已存在的相同的数据,若栈中不存在,则重新开辟内存存新数据,并且把要重新赋值的局部变量的引用指向新数据所在地址。


    B. 基本数据类型的成员变量

    成员变量:顾名思义,就是在类体中定义的变量。
    看下图:

    640?wx_fmt=png

    我们看per的地址指向的是堆内存中的一块区域,我们来还原一下代码:

     1public class Person{
    2  private int age;
    3  private String name;
    4  private int grade;
    5//篇幅较长,省略setter getter方法
    6  static void run(){
    7     System.out.println("run...."); 
    8   };
    9}
    10
    11//调用
    12Person per=new Person();

    同样是局部变量的age、name、grade却被存储到了堆中为per对象开辟的一块空间中。因此可知:基本数据类型的成员变量名和值都存储于堆中,其生命周期和对象的是一致的。


    C. 基本数据类型的静态变量

    前面提到方法区用来存储一些共享数据,因此基本数据类型的静态变量名以及值存储于方法区的运行时常量池中,静态变量随类加载而加载,随类消失而消失


    2. 引用数据类型的存储:

    上面提到:堆是用来存储对象本身和数组,而引用(句柄)存放的是实际内容的地址值,因此通过上面的程序运行图,也可以看出,当我们定义一个对象时

    1Person per=new Person();

    实际上,它也是有两个过程:

    1Person per;//定义变量
    2per=new Person();//赋值

    在执行Person per;时,JVM先在虚拟机栈中的变量表中开辟一块内存存放per变量,在执行per=new Person()时,JVM会创建一个Person类的实例对象并在堆中开辟一块内存存储这个实例,同时把实例的地址值赋值给per变量。因此可见:
    对于引用数据类型的对象/数组,变量名存在栈中,变量值存储的是对象的地址,并不是对象的实际内容。

    6. 值传递和引用传递

    前面已经介绍过形参和实参,也介绍了数据类型以及数据在内存中的存储形式,接下来,就是文章的主题:值传递和引用的传递。

    值传递:
    在方法被调用时,实参通过形参把它的内容副本传入方法内部,此时形参接收到的内容是实参值的一个拷贝,因此在方法内对形参的任何操作,都仅仅是对这个副本的操作,不影响原始值的内容。

    来看个例子:

     1public static void valueCrossTest(int age,float weight){
    2    System.out.println("传入的age:"+age);
    3    System.out.println("传入的weight:"+weight);
    4    age=33;
    5    weight=89.5f;
    6    System.out.println("方法内重新赋值后的age:"+age);
    7    System.out.println("方法内重新赋值后的weight:"+weight);
    8    }
    9
    10//测试
    11public static void main(String[] args) {
    12        int a=25;
    13        float w=77.5f;
    14        valueCrossTest(a,w);
    15        System.out.println("方法执行后的age:"+a);
    16        System.out.println("方法执行后的weight:"+w);
    17}

    输出结果:

    1传入的age:25
    2传入的weight:77.5
    3
    4方法内重新赋值后的age:33
    5方法内重新赋值后的weight:89.5
    6
    7方法执行后的age:25
    8方法执行后的weight:77.5

    从上面的打印结果可以看到:
    a和w作为实参传入valueCrossTest之后,无论在方法内做了什么操作,最终a和w都没变化。

    这是什么造型呢?!!

    下面我们根据上面学到的知识点,进行详细的分析:

    首先程序运行时,调用mian()方法,此时JVM为main()方法往虚拟机栈中压入一个栈帧,即为当前栈帧,用来存放main()中的局部变量表(包括参数)、操作栈、方法出口等信息,如a和w都是mian()方法中的局部变量,因此可以断定,a和w是躺着mian方法所在的栈帧中
    如图:

    640?wx_fmt=jpeg

    而当执行到valueCrossTest()方法时,JVM也为其往虚拟机栈中压入一个栈,即为当前栈帧,用来存放valueCrossTest()中的局部变量等信息,因此age和weight是躺着valueCrossTest方法所在的栈帧中,而他们的值是从a和w的值copy了一份副本而得,如图:
    640?wx_fmt=png
    因而可以a和age、w和weight对应的内容是不一致的,所以当在方法内重新赋值时,实际流程如图:
    640?wx_fmt=jpeg
    也就是说,age和weight的改动,只是改变了当前栈帧(valueCrossTest方法所在栈帧)里的内容,当方法执行结束之后,这些局部变量都会被销毁,mian方法所在栈帧重新回到栈顶,成为当前栈帧,再次输出a和w时,依然是初始化时的内容。
    因此:
    值传递传递的是真实内容的一个副本,对副本的操作不影响原内容,也就是形参怎么变化,不会影响实参对应的内容。


    引用传递:
    ”引用”也就是指向真实内容的地址值,在方法调用时,实参的地址通过方法调用被传递给相应的形参,在方法体内,形参和实参指向通愉快内存地址,对形参的操作会影响的真实内容。

    举个栗子:
    先定义一个对象:

     1public class Person {
    2        private String name;
    3        private int age;
    4
    5        public String getName() {
    6            return name;
    7        }
    8        public void setName(String name) {
    9            this.name = name;
    10        }
    11        public int getAge() {
    12            return age;
    13        }
    14        public void setAge(int age) {
    15            this.age = age;
    16        }
    17}

    我们写个函数测试一下:

     1public static void PersonCrossTest(Person person){
    2        System.out.println("传入的person的name:"+person.getName());
    3        person.setName("我是张小龙");
    4        System.out.println("方法内重新赋值后的name:"+person.getName());
    5    }
    6//测试
    7public static void main(String[] args) {
    8        Person p=new Person();
    9        p.setName("我是马化腾");
    10        p.setAge(45);
    11        PersonCrossTest(p);
    12        System.out.println("方法执行后的name:"+p.getName());
    13}

    输出结果:

    1传入的person的name:我是马化腾
    2方法内重新赋值后的name:我是张小龙
    3方法执行后的name:我是张小龙

    可以看出,person经过personCrossTest()方法的执行之后,内容发生了改变,这印证了上面所说的“引用传递”,对形参的操作,改变了实际对象的内容。

    那么,到这里就结题了吗?
    不是的,没那么简单,
    能看得到想要的效果
    是因为刚好选对了例子而已!!!

    下面我们对上面的例子稍作修改,加上一行代码,

    1public static void PersonCrossTest(Person person){
    2        System.out.println("传入的person的name:"+person.getName());
    3        person=new Person();//加多此行代码
    4        person.setName("我是张小龙");
    5        System.out.println("方法内重新赋值后的name:"+person.getName());
    6    }

    输出结果:

    1传入的person的name:我是马化腾
    2方法内重新赋值后的name:我是张小龙
    3方法执行后的name:我是马化腾

    `
    为什么这次的输出和上次的不一样了呢?
    看出什么问题了吗?

    按照上面讲到JVM内存模型可以知道,对象和数组是存储在Java堆区的,而且堆区是共享的,因此程序执行到main()方法中的下列代码时

    1Person p=new Person();
    2        p.setName("我是马化腾");
    3        p.setAge(45);
    4        PersonCrossTest(p);

    JVM会在堆内开辟一块内存,用来存储p对象的所有内容,同时在main()方法所在线程的栈区中创建一个引用p存储堆区中p对象的真实地址,如图:

    640?wx_fmt=png

    当执行到PersonCrossTest()方法时,因为方法内有这么一行代码:
    1person=new Person();

    JVM需要在堆内另外开辟一块内存来存储new Person(),假如地址为“xo3333”,那此时形参person指向了这个地址,假如真的是引用传递,那么由上面讲到:引用传递中形参实参指向同一个对象,形参的操作会改变实参对象的改变

    可以推出:实参也应该指向了新创建的person对象的地址,所以在执行PersonCrossTest()结束之后,最终输出的应该是后面创建的对象内容。

    然而实际上,最终的输出结果却跟我们推测的不一样,最终输出的仍然是一开始创建的对象的内容。

    由此可见:引用传递,在Java中并不存在。

    但是有人会疑问:为什么第一个例子中,在方法内修改了形参的内容,会导致原始对象的内容发生改变呢?

    这是因为:无论是基本类型和是引用类型,在实参传入形参时,都是值传递,也就是说传递的都是一个副本,而不是内容本身。

    640?wx_fmt=png

    有图可以看出,方法内的形参person和实参p并无实质关联,它只是由p处copy了一份指向对象的地址,此时:

    p和person都是指向同一个对象

    因此在第一个例子中,对形参p的操作,会影响到实参对应的对象内容。而在第二个例子中,当执行到new Person()之后,JVM在堆内开辟一块空间存储新对象,并且把person改成指向新对象的地址,此时:

    p依旧是指向旧的对象,person指向新对象的地址。

    所以此时对person的操作,实际上是对新对象的操作,于实参p中对应的对象毫无关系

    结语

    因此可见:在Java中所有的参数传递,不管基本类型还是引用类型,都是值传递,或者说是副本传递。
    只是在传递过程中:

    如果是对基本数据类型的数据进行操作,由于原始内容和副本都是存储实际值,并且是在不同的栈区,因此形参的操作,不影响原始内容。

    如果是对引用类型的数据进行操作,分两种情况,一种是形参和实参保持指向同一个对象地址,则形参的操作,会影响实参指向的对象的内容。一种是形参被改动指向新的对象地址(如重新赋值引用),则形参的操作,不会影响实参指向的对象的内容。

    以上为小编关于“值传递和引用传递”问题的思考和论证,对于这个问题,历来都是多有争论,在此希望和读者一起探讨和学习,有不同意见或者建议请假小编微信:sisi-ceo。理性评论,不喜勿喷。

    文末推广

    ↓↓↓

    640?wx_fmt=jpeg

    热门内容:

    1、冬天来了,ofo也慢慢凉了!

    2、以下几种情况,建议你趁早辞职!

    3、入职三天,公司给了100块钱叫我走人!

    4、速来围观老田的蚂蚁金服Java面试经历!

    5、仅需这一篇,带你吃透「负载均衡」!

    6、Git使用教程:最详细、最傻瓜、最浅显、真正手把手教!

    7、关于缓存命中率的几个关键问题!

    8、【面试必备】如何判断一个数是否在40亿个整数中?

    640?

    展开全文
  • C++值传递和引用传递的区别

    千次阅读 2020-05-27 17:16:02
    c++中参数传递的区别: 1.值传递: 可以想象改变的只是实参的“替身”的值,而实参本身不会被改变。...2.引用传递 可以想象成是“同一个人”,只不过把名字换了换,但本质上还是同样的。 因此,引用并不分配独
  • 通过引用传递参数允许函数成员(方法、属性、索引器、运算符构造函数)更改参数的,并保持该更改。 二、传递类型参数类型变量直接包含其数据,这与引用类型变量不同,后者包含对其数据的引用。因此,向方法...
  • 【JAVA】 什么是值传递和引用传递

    万次阅读 多人点赞 2019-06-04 11:10:05
    值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 一般认为,java内的基础类型数据传递都是...
  • 值传递和引用传递(地址传递)的区别

    千次阅读 2019-08-07 10:38:05
    也许大家对于被值传递和引用传递(看了些别人的博客也有人说只有值传递)弄得傻傻分不清楚,我个人之前也是这样过来的,自己也思考了一番,后来才弄清楚了,结合大多数人的想法总结: 八大基本数据类型:(byte, ...
  • 什么是值传递和引用传递

    千次阅读 2017-09-19 15:17:47
    一、什么是值传递和引用传递值传递,是对于基本数据类型的变量而言的。传递的是该变量的一个副本,改变副本并不影响原变量 引用传递,是对于对象型变量而言的。传递的是该变量地址的一个副本,并不是该对象本身...
  • 本文章仅为个人学习总结,如有错误请指正。    首先区分,引用传递和引用类型无关,值传递和值类型无关。  建议自己定义一个类,通过类来感受... 引用传递和值传递最大的区别为能否改变所引用的对象,当一个实参传
  • 什么是值传递和引用传递

    千次阅读 2019-07-08 21:42:24
    1.值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参 数的值。 2.引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相...
  • 学过java基础的人都知道,在java中参数的传递过程中有值传递和应用传递,那么这两个到底有什么区别呢,下面我通过例子为大家详细的介绍下。 我们都知道Java中有八种数据类型,基础数据类型分别是:byte,short,int...
  • C#笔记(基础)值传递和引用传递,适合刚开始学习C#的朋友来学习,阅览
  • 一般认为,java内的基础类型数据传递都是值传递. java中实例对象的传递是引用传递值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。引用传递一般是对于对象型变量而言的,传递的是该...
  • 什么是值传递和引用传递?

    千次阅读 2018-08-14 08:10:16
    关于值类型与引用类型,值传递引用传递的归纳,总结一下,分享给大家: 一、值类型与引用类型 1.堆栈中的存放: <1>值类型默认存放在栈中,但当值类型是在引用类型中声明的时候,则存放在其所在...
  • 一文搞懂Java的值传递和引用传递

    千次阅读 多人点赞 2020-07-31 14:46:17
    文章目录实参与形参值传递引用传递...错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的参数如果是普
  • 函数参数传递的两种方式——值传递和引用传递

    万次阅读 多人点赞 2018-10-23 15:50:05
    值传递包括实实在在的值传递以及指针传递(指针传递参数本质上是值传递的方式,它所传递的是一个地址值),传递的都是实参的一个拷贝。 1、实实在在的“值”传递 #include <iostream> #include &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 638,280
精华内容 255,312
关键字:

值传递和引用传递