精华内容
下载资源
问答
  • 值传递和对象引用传递
    千次阅读
    2018-09-15 16:08:46

        刚刚接触Java时应该听说过一句“万物皆对象”,《Java编程思想》一书中也描述对象“将对象视为奇特的变量,它可以存储数据,除此之外,还可以要求它在自身上执行操作。理论上讲,可以抽象待求解问题的任何概念化构件,将其表示为程序中的对象”。对于对象的引用,心里大概知道,却不知怎么表达。还有一个问题就是Java是值传递还是引用传递,在C语言中这个问题看到的比较多,在Java中似乎没怎么探讨过。下面围绕上面两个问题来分析!

     

    *什么是对象引用?

        在C语言中指针是重点亦是难点,到现在还是觉得指针是一个高深的东西,因为它可以直接操作内存,简单地说,指针可以指向一个物理地址,然后操作这一块内存。在Java中的对象的引用和C、C++中的指针是比较像的,不过也只是比较像而已,有人觉得Java中的对象就是一个指针,但事实上,Java中的对象引用和C++中的引用在语法上更加接近,不过两者也存在很大差别。第一版的《Java编程思想》把Java中的对象引用叫做“句柄”,不过我们现在更习惯用“引用”。

         对于Java中的对象引用的解释可以用《Java编程思想》的一段话解释,“每种编程语言都有自己的数据处理方式,有些时候,程序员必须注意将这些要处理的数据是什么类型。你是直接操作元素,还是用某种基于特殊语法的间接表示(例如C/C++里的指针)来操作对象。所有这些在Java中得到了简化,一却都被视为对象。因此,我们可以采用一种统一的语法。尽管一切都被视为对象,但操作的标识符实际是指向一个对象的‘引用’ ”。

    再举一个这本书中有关对象个对象引用的例子:

        对象和对象引用就好比电视机和遥控器,对象是电视机,对象引用是遥控器,即遥控器用来控制电视机,遥控器和电视是关联起来的,我们要控制电视,只需要一个遥控器即可。若有String s; ,这里的s创建了一个字符串引用,就相当于有了一个遥控器,可是没有电视机,可是记得吗,还有万能遥控器,,不过在配对之前,万能遥控器是不与任何一台电视机相关联的,当配对成功之后它就与特定的电视机产生了管理,所以说这个s其实现在还是一个还没有指向任何字符串对象的字符串引用,当我们通过new的方式创建了一个字符串对象,其实就相当于给这个引用关联了一个对象,这个引用关联了一个对象,这个引用就指向了这个对象。

     

    弄清楚了Java中的引用,下面补充一段关于String和StringBuffer的例子:

    public static void main(String[] args) {
        String s1 = new String("hello String!");
        String s2 = s1;
        s2 = "你好 String!";
    
        StringBuffer s3 = new StringBuffer("hello");
        StringBuffer s4 = s3;
        s4.append(" StringBuffer!");
    
        System.out.println("s1: "+s1);   //s1: hello String!
        System.out.println("s2: "+s2);   //s2: 你好 String!
        System.out.println("s3: "+s3);   //s3: hello StringBuffer!
        System.out.println("s4: "+s4);   //s4: hello StringBuffer!
    }
    

    之前总结过:String一旦创建就不会再改变,上述代码中,之前s1和s2指向的是同一个对象,但是当是s2重新赋值的话,所指向的对象就变了,这点对于StringBuffer不同,因为它创建的字符串存在缓冲流,所以s3和s4一开始指向的是同一个对象,然后s4改变了这个对象,这个时候其实s3和s4指向的还是同一个对象,所以内容也是相同的。这里记住一个很重要的知识点——

        如果两个引用指向同一个对象,不管哪个引用去改变这个对象,其结果是对象的内容都会发生改变,而且只有一个对象,但是String是一个特例!

     

    *Java中是值传递还是还是引用传递?

        首先,答案是值传递,属于基础知识,却往往被我们忽视。对于Java中的传递方式必须要深刻理解什么是值,什么是引用,刚好上面我们分析了什么是对象的引用。下面还是来看一个例子:

    public static void main(String[] args) {
            String str = "hello";
            setString(str);
            System.out.println(str);  //hello
        }
        public static void setString(String str) {
            str = str + "String";
        }

        在这个例子中,不要被setString()方法中的str迷惑了,这个str和main方法中的str是不一样的,先不谈值传递和引用传递,我们知道String一旦创建是不可变的,所以这里的str是不会变的。实际上是setString()中的这个str指向了新创建的字符串对象“hello String”。

     

        对于Java中的传参我们可以分为基础类型和引用类型,但两者传参方式都是值传递,对于基础数据类型传参方式是值传递是比较好理解的,重点在于引用类型。还是一个例子:

    Integer a = new Integer(1);
    Integer b = a;
    b++ ;
    System.out.println("a="+a+"\t b="+b);  //a=1	 b=2

        这个例子再次说明Java的引用类型是值传递方式传参的,因为a的值没有随着b的改变同时改变。引用类型中的值传递中“值”指的是什么呢?这里的值其实就是引用所存储的对象的地址值,其实b是a的一个复制品,这个b是独立存在的一个引用,在没有将a复制给它的时候,她还是一个空引用,谁也不指向,但是当a复制给它后,就相当于b存储了和a一样的地址,都指向同一个对象,如图1,但是一旦b自增就相当于Integer b = new Integer(2);,就变成了图2,即b引用的地址就变了。

          所以Java中传参的方式只有一种,那就是值传递,另外,我们知道对于引用都是存在栈中的,而实际的对象是存在堆中的,栈中的引用存放了可以指向实际对象的地址,而引用数据类型的传参,传的就是这个地址!

     

    更多相关内容
  • java 中没有引用传递,都是传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • 如果函数收到的是一个可变对象(比如字典 或者列表)的引用,就能修改对象的原始——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象(比如数字、字符或者元组)的引用,就不能 直接修改原始对象...
  • java中的传递和引用传递

    千次阅读 2021-12-07 20:07:09
    引用传递(Pass By Reference或者Call By Reference)一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。一般java中实例(包装)对象的传递是引用传递。 一、基本类型引用类型在内存...

    个人理解,可能会有错误之处,请仔细甄别,谨慎参考!如有错误或不同见解请指出!

    值传递(Pass By Value或者Call By Value)是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。一般java中的基础类型数据传递都是值传递。
    引用传递(Pass By Reference或者Call By Reference)一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。一般java中实例(包装)对象的传递是引用传递。

    一、基本类型和引用类型在内存中的不同之处

    int num = 10;
    String str = "hello";


    如图所示,num是基本类型,值就直接保存在变量中。而str是引用类型,变量中保存的只是实际对象的地址。一般称这种变量为"引用",引用指向实际对象,实际对象中保存着内容。

    二、赋值时内存的变化

    int num = 24;
    String str = "world";

    对于基本类型num,赋值运算符会直接改变变量的值,原来的值被覆盖掉。对于引用类型str,赋值运算符会改变引用中所保存的地址,原来的地址被覆盖掉。但是原来的对象(“hello” 字符串对象)不会被改变。(没有被任何引用所指向的对象是垃圾,会被垃圾回收器回收)

    三、调用方法时发生了什么,参数传递基本上就是赋值操作

    第一个例子:基本类型

    void change(int value) {
        value = 100;
    }
    change(num); // num 没有被改变

    第二个例子:引用类型没有使用改变自身方法的方法

    void change(String a) {
        a = "唐";
    }
    change(str); // str没有被改变

    或:

    StringBuilder stri = new StringBuilder("唐");
    void change(StringBuilder builder) {
        builder = new StringBuilder("宋");
    }
    change(stri); // stri没有被改变,还是 "唐"。

     第三个例子:引用类型使用了改变自身方法的方法

    StringBuilder stri = new StringBuilder("明");
    void change(StringBuilder builder) {
        builder.append("清");
    }
    change(stri); // stri被改变了,变成了"清"。

    第三个例子的图解:


    builder.append("清")之后

    参考:

    java基本数据类型传递与引用传递区别详解_zejian的博客-CSDN博客_java值传递和引用传递java的值传递和引用传递在面试中一般都会都被涉及到,今天我们就来聊聊这个问题,首先我们必须认识到这个问题一般是相对函数而言的,也就是java中的方法参数,那么我们先来回顾一下在程序设计语言中有关参数传递给方法(或函数)的两个专业术语:按值调用(call by value)按引用调用(call by reference)所谓的按值调用表示方法接收的是调用着提https://blog.csdn.net/javazejian/article/details/51192130

     

    展开全文
  • Java传递和引用传递详细说明

    千次阅读 多人点赞 2020-07-14 15:53:17
    学过Java基础的人都知道:传递和引用传递是初次接触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中所有的参数传递,不管基本类型还是引用类型,都是值传递,或者说是副本传递。
    只是在传递过程中:

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

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

    原文转至:https://blog.csdn.net/bntx2jsqfehy7/article/details/83508006

    展开全文
  • 对象引用传递和值传递

    千次阅读 2018-07-04 15:42:00
    我们在开发的过程中,经常会遇见对象传递,和对象引用传递,老是分不清楚。 今天以下面两个例子,结合内存分析,来讲解传递和引用传递

    我们在开发的过程中,经常会遇见对象的值传递,和对象的引用传递,老是分不清楚。

    今天以下面两个例子,结合内存分析,来讲解值传递和引用传递。

    值传递

    源代码

    
    /**
     * Created By zby on 20:46 2022/7/27
     * 学生类
     */
    public class Student{
    
        private String name;
        
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void changeStudentName(Student s) {
            s = new Student();
            s.setName("nihao");
        }
    
        public static void main(String[] args) {
       1     Student student = new Student();
       2     student.setName("珠宝呀");
            
       3    *System.out.println(student.getName());*
            
       4     student.changeStudentName(student);
    
       5    *System.out.println(student.getName());*
    	}
    }
    output:
    		珠宝呀
    		珠宝呀
    

    输出结果:

    在这里插入图片描述

    你会发现,即便我调用了changeStudentName方法,其输出结果也是一样的,为什么会这样呢?

    语句1

    我们来画一个类加载的JVM结构图,当我们执行语句1时,首先会在栈里分配一个地址空间存储指向student对象1的引用的首地址:

    这里写图片描述

    语句2

    当我们执行语句2的时候,在栈里面分配一个临时变量name,临时变量存储是常量池当中的“珠宝”的地址,而通过set方法中的this.name=name,此时对象的属性存储的临时变量的副本地址,通过这个方法可得:

    String p="珠宝呀";
    student.setName(p);
    student.setName("珠宝");
    System.out.println("student-->"+student.getName());
    System.out.println("p-->"+p);
    
    output:
    	student-->珠宝
    	p-->珠宝呀
    

    发现p的值并不没改变,而对象name重新获取新的副本。这个是按值传递。

    这里写图片描述

    语句4

    当方法执行语句4时:此时获取了student对象的副本,副本指向了新的Student对象,并且set了新的名字,而Student初值并没有改变,因而,输出的结果是没有改变。

    引用传递

    如果将StudentName的返回对象改变了,就会出现不同的结果:

     public Student changeStudentName(Student s) {
            s = new Student();
            s.setName("nihao");
    
           return s;
        }
    
        public static void main(String[] args) {
    
            Student student = new Student();
            System.out.println(student.getName());
    
            String p="珠宝呀";
            student.setName(p);
            student.setName("珠宝");
            System.out.println("student-->"+student.getName());
            System.out.println("p-->"+p);
    
            student = student.changeStudentName(student);
    
            System.out.println("student-->"+student.getName());
        }
    
    	output:
    		student-->珠宝
    		p-->珠宝呀
    		student-->nihao
    

    输出结果:

    在这里插入图片描述

    因为,通过调用 student.changeStudentName(student);这个方法,返回的是一个新的对象的引用,而student重新指向了新的引用对象,故而,值就被改变了。这个是按引用传递数据。

    总结

    通过以上两段代码的分析,应该对值传递和引用传递,有个大致的了解了。

    展开全文
  • 快速区分传递和引用传递
  • Java 传递和引用传递

    千次阅读 2022-03-31 19:47:03
    传递:在调用函数的时候,将实际参数复制一份传递到函数中,这样在函数中对参数进行... 传递 引用传递 根本区别 会创建一个副本(copy) 不创建副本 结果 函数中无法改变原来的对象 函数可以改变原来的对象对象创建.
  • js数组和对象 值传递和引用

    千次阅读 2019-09-09 16:25:53
    js数组和对象分为值传递和引用俩种方式。 对象值传递 let arr={a:1,b:2} let row =Object.assign({}, arr);//row对象之后的操作不会影响到源对象arr 可能有些人对assign不太了解,看一下下面代码就会知道如何使用 ...
  • 传递与引用传递详解

    万次阅读 多人点赞 2020-10-29 23:11:11
    1、关于传递与引用传递的定义 传递:是指在调用函数时,将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,就不会影响到实际参数 如下图所示,当传递参数之前会将参数进行复制,函数中修改了...
  • java的传递和引用传递

    千次阅读 2021-02-26 08:26:02
    昨天博主在对于传递和引用传递这里栽了一个大坑啊,导致一下午时间都浪费在这里,我们先说下传递和引用传递java官方解释:传递:(形式参数类型是基本数据类型):方法调用时,实际参数把它的传递给对应的形式...
  • ECMAScript中有5种简单数据类型(也称为基本数据类型):Undefined、Null、Boolean、NumberString。还有1种复杂数据类型——Object,Object本质上是由一组无序的名对组成的。ECMScript不支持任何创建自定义类型...
  • Java中是传递和引用传递

    千次阅读 2022-01-15 12:22:33
    传递 / 引用传递 传递:就是在方法调用的时候,实参是将自己的一份拷贝赋给形参,在方法内,对该参数的修改不影响原来的实参。 引用传递:是在方法调用的时候,实参将自己的地址传递给形参,此时方法内对该...
  • 1、按值传递对象与传递引用:  通常,编写使用对象作为参数的函数时,应按引用而不是按传递对象。这样做的原因之一是提高效率。按值传递对象涉及到生成临时拷贝,即调用复制构造函数,然后调用析构函数。调用...
  • Java的传递和引用传递

    千次阅读 2022-04-20 16:12:38
    Java的传递引用传递 传递:对形参的修改不会影响到实参 。引用传递:对实参的修改能够影响到实参 Java是传递:如果是基本数据...二、对于引用类型:(当对象引用传递给方法时,其实是创建了一个引用副本,但
  • Java 是传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对你有所帮助。 首先说下我的感受,这个题目出的很好,但是在 ...
  • 深入理解--Java按传递引用传递

    万次阅读 多人点赞 2017-07-20 15:48:49
    引言最近刷牛客网上的题目时碰到不少有关Java按传递引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?Java按...
  • Java中的参数传递,到底是传递还是引用传递

    千次阅读 多人点赞 2020-05-12 18:23:29
    错误理解一:传递和引用传递,区分的条件是传递的内容,如果是个,就是传递。如果是个引用,就是引用传递。 错误理解二:Java是引用传递。 错误理解三:传递的参数如果是普通类型,那就是传递,如果是对象,...
  • php 引用传递和值传递深入解析

    千次阅读 2019-03-30 17:10:28
    PHP 传递和引用传递的区别。什么时候传值什么时候传引用 先来张图,然后再讲后面的 按传递 函数范围内对的任何改变在函数外部都会被忽略 传递是把拷贝一份,两个变量指向两个内存地址 传递没什么好说...
  • Python参数传递:传递和引用传递

    千次阅读 2021-05-08 13:00:10
    2.2 不可变对象对象的内存不能被改变,如果变量引用了不可变的对象,当改变该变量时,由于其所指向的对象不能都被改变,因此需要把原来的复制出来一份后再改变;即在内存中开辟一块新的区域,变量再指向...
  • 看到这样一个例子来说明是传递而不是引用传递 个人观点:简述一下一个概念 Student s1=new Student(); 对于这个语句来说s1是对象的一个引用,具体创建对象的过程是new Student()这个来完成的,对象是一个...
  • java 值传递与址(引用传递

    千次阅读 2022-03-21 20:11:56
    一、java中方法参数传递方式是本质上都是“传递 如果参数是基本类型(传“实际”): ...1. “String8大基本类型的包装类”是不可变类型,即特殊的引用类型,所以每次修改操作都是新创建的对象,栈中的地.
  • 传递与引用传递 传递:方法调用时,实际参数把它的传递给对应的形式参数,方法执行中形式参数的改变不影响实际参数的引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的)被...
  • js中的传递与引用传递

    千次阅读 2018-12-03 16:25:34
    要说js的赋值方式时首先要说明js的数值类型:基本类型和引用类型。 基本数据类型 基本的数据类型有:undefined,boolean,number,string,null。 基本类型存放在栈区,访问是按访问的,就是说你可以操作保存在...
  • Java传递与引用传递的区别

    千次阅读 多人点赞 2021-09-09 22:55:57
    Java传递与引用传递 文章目录Java传递与引用传递前景实参与形参传递与引用传递Java中的...错误理解一:传递和引用传递,区分的条件是传递的内容,如果是个,就是传递。如果是个引用,就是引用传递。 错误
  • 为什么Java只有值传递

    2021-01-20 02:08:46
    我们先看一下传递和引用传递的概念...传递的函数中无法改变原始对象引用传递中函数 可以改变原始对象 我们通过例子理解一下Java的传递: public static void main(String[] args) { int a = 10; int b = 20;
  • JAVA引用和对象的关系,还有值传递[归类].pdf
  • Java 到底是传递还是引用传递

    千次阅读 2022-02-15 11:48:07
    一句话概括传递和引用传递的区别: 传递是传递实参副本,函数修改不会影响实参;引用传递是传递实参地址,函数修改会影响实参。 下面一个简单的面试题解释下: 面试官:你好,你能说出下面个程序的执行结果吗...
  • 数组不是Java中的原始类型,但它们也不是对象,所以它们是通过传递还是通过引用传递?它是否依赖于数组包含的内容,例如引用或基元类型?数组是对象,是的,但是Java中的任何东西都不是通过引用传递的。所有参数...
  • Java面向对象值传递和引用传递Java面向对象值传递和引用传递Java面向对象值传递和引用传递Java面向对象值传递和引用传递

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 724,367
精华内容 289,746
热门标签
关键字:

值传递和对象引用传递