精华内容
下载资源
问答
  • java值传递
    2022-03-21 20:11:56

    一、java中方法参数传递方式是本质上都是“值”传递

    如果参数是基本类型(传“实际值”):

    由于栈中存的就是“实际值”(java基本类型的值存储在栈中,不在堆中),所以传递的是基本类型的“实际值”的拷贝。

     如果参数是引用类型(传“地址值”):

    由于栈中存的是地址(该地址指向堆内存中存储位置,即引用),所以传递的是“堆中的地址”的拷贝。所以我们说成是“引用(址)传递”。

    注意:
    1. “
    String和8大基本类型的包装类”是不可变类型,即特殊的引用类型,所以每次修改操作都是新创建的对象,栈中的地址不断更换,所以出现了不能修改值的效果,让大家误以为是值传递了。
    2. 而一般对我们自己创建的类进行修改操作,就会顺着引用的地址“找到并修改掉”原来的值,所以达到了引用传递的效果。

    二、补充:

    String与8种基本数据类型的包装类

    8种基本数据类型采用值传递,其包装类型与String与其他我们手写的类都是引用传递只是由于String和8种包装类都是不可变类,所以每次操作都是新创一个对象并重新赋给引用;在函数调用的时候,如果形参是String或者8种包装类型,操作形参不会影响实参,操作形参相当于重新创建对象不会影响原实参。

    可变与不可变

    不可变:
    String8种包装类型、BigInteger、BigDecimal是不可变类,不可变的意思是每次更换值都会重新生成对象并赋给引用。不用考虑线程安全。我们也可以设计自己的不可变类。

    可变:
    其他我们手写的实体类一般都是可变类。


    参考:Java 到底是值传递还是引用传递? - 知乎 

    JAVA不可变类与可变类、值传递与引用传递深入理解 - QiaoZhi - 博客园

    更多相关内容
  • Java值传递

    千次阅读 2020-11-07 15:47:47
    这篇文章中,我从什么是方法的实际参数和形式参数开始,给你讲解为什么说Java中只有值传递。 辟谣时间 关于这个问题,在StackOverflow上也引发过广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多...

    对于初学者来说,要想把这个问题回答正确,是比较难的。在第二天整理答案的时候,我发现我竟然无法通过简单的语言把这个事情描述的很容易理解,遗憾的是,我也没有在网上找到哪篇文章可以把这个事情讲解的通俗易懂。所以,就有了我写这篇文章的初衷。这篇文章中,我从什么是方法的实际参数和形式参数开始,给你讲解为什么说Java中只有值传递。

    辟谣时间

    关于这个问题,在StackOverflow上也引发过广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的是错误的。还有的人可能知道Java中的参数传递是值传递,但是说不出来为什么。

    在开始深入讲解之前,有必要纠正一下大家以前的那些错误看法了。如果你有以下想法,那么你

    错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。


    错误理解二:Java是引用传递。


    错误理解三:传递的参数如果是普通类型,那就是值传递,如果是对象,那就是引用传递。

    实参与形参

    我们都知道,在Java中定义方法的时候是可以定义参数的。比如Java中的main方法:

    public static void main(String[] args)
    

    这里面的args就是参数。参数在程序语言中分为形式参数和实际参数。

    形式参数:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。


    实际参数:在调用有参函数时,主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时,函数名后面括号中的参数称为“实际参数”。

    简单举个例子:

    public static void main(String[] args) {
       ParamTest pt = new ParamTest();
       pt.sout("Hollis");//实际参数为 Hollis
    }
    
    public void sout(String name) { //形式参数为 name
       System.out.println(name);
    }
    

    实际参数是调用有参方法的时候真正传递的内容,而形式参数是用于接收实参内容的参数。

    值传递与引用传递

    上面提到了,当我们调用一个有参函数的时候,会把实际参数传递给形式参数。但是,在程序语言中,这个传递过程中传递的两种情况,即值传递和引用传递。我们来看下程序语言中是如何定义和区分值传递和引用传递的。

    值传递(pass by value)是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。


    引用传递(pass by reference)是指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    有了上面的概念,然后大家就可以写代码实践了,来看看Java中到底是值传递还是引用传递 ,于是,最简单的一段代码出来了:

    public static void main(String[] args) {
       ParamTest pt = new ParamTest();
    
       int i = 10;
       pt.pass(i );
       System.out.println("print in main , i is " + i);
    }
    
    public void pass(int j) {
       j = 20;
       System.out.println("print in pass , j is " + j);
    }
    

    上面的代码中,我们在pass方法中修改了参数j的值,然后分别在pass方法和main方法中打印参数的值。输出结果如下:

    print in pass , j is 20
    print in main , i is 10
    

    可见,pass方法内部对name的值的修改并没有改变实际参数i的值。那么,按照上面的定义,有人得到结论:Java的方法传递是值传递。

    但是,很快就有人提出质疑了(哈哈,所以,不要轻易下结论咯。)。然后,他们会搬出以下代码:

    public static void main(String[] args) {
       ParamTest pt = new ParamTest();
    
       User hollis = new User();
       hollis.setName("Hollis");
       hollis.setGender("Male");
       pt.pass(hollis);
       System.out.println("print in main , user is " + hollis);
    }
    
    public void pass(User user) {
       user.setName("hollischuang");
       System.out.println("print in pass , user is " + user);
    }
    

    同样是一个pass方法,同样是在pass方法内修改参数的值。输出结果如下:

    print in pass , user is User{name='hollischuang', gender='Male'}
    print in main , user is User{name='hollischuang', gender='Male'}
    

    经过pass方法执行后,实参的值竟然被改变了,那按照上面的引用传递的定义,实际参数的值被改变了,这不就是引用传递了么。于是,根据上面的两段代码,有人得出一个新的结论:Java的方法中,在传递普通类型的时候是值传递,在传递对象类型的时候是引用传递。

    但是,这种表述仍然是错误的。不信你看下面这个参数类型为对象的参数传递:

    public static void main(String[] args) {
       ParamTest pt = new ParamTest();
    
       String name = "Hollis";
       pt.pass(name);
       System.out.println("print in main , name is " + name);
    }
    
    public void pass(String name) {
       name = "hollischuang";
       System.out.println("print in pass , name is " + name);
    }
    

    上面的代码输出结果为

    print in pass , name is hollischuang
    print in main , name is Hollis
    

    这又作何解释呢?同样传递了一个对象,但是原始参数的值并没有被修改,难道传递对象又变成值传递了?

    Java中的值传递

    上面,我们举了三个例子,表现的结果却不一样,这也是导致很多初学者,甚至很多高级程序员对于Java的传递类型有困惑的原因。

    其实,我想告诉大家的是,上面的概念没有错,只是代码的例子有问题。来,我再来给大家画一下概念中的重点,然后再举几个真正恰当的例子。

    值传递(pass by value)是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。

    引用传递(pass by reference)是指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    那么,我来给大家总结一下,值传递和引用传递之前的区别的重点是什么。

    在这里插入图片描述
    我们上面看过的几个pass的例子中,都只关注了实际参数内容是否有改变。如传递的是User对象,我们试着改变他的name属性的值,然后检查是否有改变。其实,在实验方法上就错了,当然得到的结论也就有问题了。

    为什么说实验方法错了呢?这里我们来举一个形象的例子。再来深入理解一下值传递和引用传递,然后你就知道为啥错了。

    你有一把钥匙,当你的朋友想要去你家的时候,如果你直接把你的钥匙给他了,这就是引用传递。这种情况下,如果他对这把钥匙做了什么事情,比如他在钥匙上刻下了自己名字,那么这把钥匙还给你的时候,你自己的钥匙上也会多出他刻的名字。

    你有一把钥匙,当你的朋友想要去你家的时候,你复刻了一把新钥匙给他,自己的还在自己手里,这就是值传递。这种情况下,他对这把钥匙做什么都不会影响你手里的这把钥匙。

    但是,不管上面哪种情况,你的朋友拿着你给他的钥匙,进到你的家里,把你家的电视砸了。那你说你会不会受到影响?而我们在pass方法中,改变user对象的name属性的值的时候,不就是在“砸电视”么。你改变的不是那把钥匙,而是钥匙打开的房子。

    还拿上面的一个例子来举例,我们真正的改变参数,看看会发生什么?

    public static void main(String[] args) {
       ParamTest pt = new ParamTest();
    
       User hollis = new User();
       hollis.setName("Hollis");
       hollis.setGender("Male");
       pt.pass(hollis);
       System.out.println("print in main , user is " + hollis);
    }
    
    public void pass(User user) {
       user = new User();
       user.setName("hollischuang");
       user.setGender("Male");
       System.out.println("print in pass , user is " + user);
    }
    

    上面的代码中,我们在pass方法中,改变了user对象,输出结果如下:

    print in pass , user is User{name='hollischuang', gender='Male'}
    print in main , user is User{name='Hollis', gender='Male'}
    

    我们来画一张图,看一下整个过程中发生了什么,然后我再告诉你,为啥Java中只有值传递。
    在这里插入图片描述
    稍微解释下这张图,当我们在main中创建一个User对象的时候,在堆中开辟一块内存,其中保存了name和gender等数据。然后hollis持有该内存的地址0x123456(图1)。

    当尝试调用pass方法,并且hollis作为实际参数传递给形式参数user的时候,会把这个地址0x123456交给user,这时,user也指向了这个地址(图2)。

    然后在pass方法内对参数进行修改的时候,即user = new User();,会重新开辟一块0X456789的内存,赋值给user。后面对user的任何修改都不会改变内存0X123456的内容(图3)。

    上面这种传递是什么传递?肯定不是引用传递,如果是引用传递的话,在执行user = new User();的时候,实际参数的引用也应该改为指向0X456789,但是实际上并没有。

    通过概念我们也能知道,这里是把实际参数的引用的地址复制了一份,传递给了形式参数。所以,上面的参数其实是值传递,把实参对象引用的地址当做值传递给了形式参数。

    我们再来回顾下之前的那个“砸电视”的例子,看那个例子中的传递过程发生了什么。

    在这里插入图片描述
    同样的,在参数传递的过程中,实际参数的地址0X1213456被拷贝给了形参,只是,在这个方法中,并没有对形参本身进行修改,而是修改的形参持有的地址中存储的内容。

    所以,值传递和引用传递的区别并不是传递的内容。而是实参到底有没有被复制一份给形参。在判断实参内容有没有受影响的时候,要看传的的是什么,如果你传递的是个地址,那么就看这个地址的变化会不会有影响,而不是看地址指向的对象的变化。就像钥匙和房子的关系。

    那么,既然这样,为啥上面同样是传递对象,传递的String对象和User对象的表现结果不一样呢?我们在pass方法中使用name = “hollischuang”;试着去更改name的值,阴差阳错的直接改变了name的引用的地址。因为这段代码,会new一个String,再把引用交给name,即等价于:

    name = new String("hollischuang");
    

    而原来的那个"Hollis"字符串还是由实参持有着的,所以,并没有修改到实际参数的值。

    在这里插入图片描述
    所以说,Java中其实还是值传递的,只不过对于对象参数,值的内容是对象的引用。

    总结

    无论是值传递还是引用传递,其实都是一种求值策略(Evaluation strategy)。在求值策略中,还有一种叫做按共享传递(call by sharing)。其实Java中的参数传递严格意义上说应该是按共享传递。

    按共享传递,是指在调用函数时,传递给函数的是实参的地址的拷贝(如果实参在栈中,则直接拷贝该值)。在函数内部对参数进行操作时,需要先拷贝的地址寻找到具体的值,再进行操作。如果该值在栈中,那么因为是直接拷贝的值,所以函数内部对参数进行操作不会对外部变量产生影响。如果原来拷贝的是原值在堆中的地址,那么需要先根据该地址找到堆中对应的位置,再进行操作。因为传递的是地址的拷贝所以函数内对值的操作对外部变量是可见的。

    简单点说,Java中的传递,是值传递,而这个值,实际上是对象的引用。

    而按共享传递其实只是按值传递的一个特例罢了。所以我们可以说Java的传递是按共享传递,或者说Java中的传递是值传递。

    展开全文
  • Java值传递与引用传递的区别

    千次阅读 多人点赞 2021-09-09 22:55:57
    Java值传递与引用传递 文章目录Java值传递与引用传递前景实参与形参值传递与引用传递Java中的值传递总结 前景 关于这个问题,引发过很多广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的...

    Java值传递与引用传递

    前景

    关于这个问题,引发过很多广泛的讨论,看来很多程序员对于这个问题的理解都不尽相同,甚至很多人理解的是错误的。还有的人可能知道Java中的参数传递是值传递,但是说不出来为什么。
    在开始深入讲解之前,有必要纠正一下大家以前的那些错误看法了。如果你有以下想法,那么你有必要好好阅读本文。

    • 错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。
    • 错误理解二: Java是引用传递。
    • 错误理解三:传递的参数如果是普通类型,那就是值传递,如果是对象,那就是引用传递。

    实参与形参

    我们都知道,在Java中定义方法的时候是可以定义参数的。比如Java中的main方法, public static void main(String[ ] args),这里面的args就是参数。参数在程序语言中分为形式参数和实际参数。
    形式参数:是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。
    实际参数:在调用有参函数时,主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时,函数名后面括号中的参数称为“实际参数”。
    简单举个例子:

    public static void main( String[ ] args) {
    ParamTest pt = new ParamTest();
    pt.sout( "Hollis");//实际参数为Hollis
    }
    public void sout( String name) {/!形式参数为name
    system.out.println(name);
    }
    
    

    实际参数是调用有参方法的时候真正传递的内容,而形式参数是用于接收实参内容的参数。

    值传递与引用传递

    上面提到了,当我们调用一个有参函数的时候,会把实际参数传递给形式参数。但是,在程序语言中,这个传递过程中传递的两种情况,即值传递和引用传递。我们来看下程序语言中是如何定义和区分值传递和引用传递的。

    值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
    引用传递是指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    有了上面的概念,然后大家就可以写代码实践了,来看看Java中到底是值传递还是引用传递,于是,最简单的一段代码出来了:

    public static void main( String[] args) {
         ParamTest pt = new ParamTest();
        int i = 10;
        pt.pass(i);
        System.out.println( "print in main , i is " +i);
    }
    public void pass(int j){
        j = 20;
        system.out.println( "print in pass , j is " + j);
    }
    
    

    上面的代码中,我们在pass方法中修改了参数j的值,然后分别在pass方法和main方法中打印参数的值。输出结果如下:

    print in pass , j is 20
    print in main , i is 10
    

    可见,pass方法内部对i的值的修改并没有改变实际参数i的值。那么,按照上面的定义,有人得到结论: Java的方法传递是值传递。
    但是,很快就有人提出质疑了(哈哈,所以,不要轻易下结论咯。)。然后,他们会搬出以下代码:

    public static void main(String[ ] args) {
        ParamTest pt = new ParamTest();
        User hollis = new User();
        hollis.setName( "Hollis");
        hollis.setGender("Male");
        pt.pass(hollis);
        system.out.println( "print in main , user is " + hollis);
    }
    public void pass(User user) {
        user.setName( "hollischuang");
        System.out.println( "print in pass , user is " + user);
    }
    

    同样是一个pass方法,同样是在pass方法内修改参数的值。输出结果如下:

    print in pass , user is User{name='hollischuang', gender='Male '}
    print in main , user is User{name='hollischuang' , gender='Male '}
    

    经过pass方法执行后,实参的值竟然被改变了,那按照上面的引用传递的定义,实际参数的值被改变了,这不就是引用传递了么。于是,根据上面的两段代码,有人得出一个新的结论:Java的方法中,在传递普通类型的时候是值传递,在传递对象类型的时候是引用传递。
    但是,这种表述仍然是错误的。不信你看下面这个参数类型为对象的参数传递:

    public static void main( string[] args) {
        ParamTest pt = new ParamTest();
        string name = "Hollis";
        pt.pass(name ) ;
        System.out.println( "print in main , name is " + name);
    }
    public void pass(string name) {
        name = "hollischuang";
        system.out.println( "print in pass , name is " + name);
    }
    
    
    

    上面的代码输出结果为

    print in pass , name is hollischuangprint in main , name is Hollis
    

    这又作何解释呢?同样传递了一个对象,但是原始参数的值并没有被修改,难道传递对象又变成值传递了?

    Java中的值传递

    上面,我们举了三个例子,表现的结果却不一样,这也是导致很多初学者,甚至很多高级程序员对于Java的传递类型有困惑的原因。其实,我想告诉大家的是,上面的概念没有错,只是代码的例子有问题。来,我再来给大家画—下概念中的重点,然后再举几个真正恰当的例子。

    值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
    引用传递是指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

    那么,我来给大家总结一下,值传递和引用传递之前的区别的重点是什么。

    值传递引用传递
    根本区别会创建副本 copy不创建副本
    所有函数中无法改变原始对象函数中可以改变原始对象

    我们上面看过的几个pass的例子中,都只关注了实际参数内容是否有改变。如传递的是User对象,我们试着改变他的name属性的值,然后检查是否有改变。其实,在实验方法上就错了,当然得到的结论也就有问题了。
    为什么说实验方法错了呢?这里我们来举一个形象的例子。再来深入理解一下值传递和引用传递,然后你就知道为啥错了。
    你有一把钥匙,当你的朋友想要去你家的时候,如果你直接把你的钥匙给他了,这就是引用传递。这种情况下,如果他对这把钥匙做了什么事情,比如他在钥匙上刻下了自己名字,那么这把钥匙还给你的时候,你自己的钥匙上也会多出他刻的名字。
    你有一把钥匙,当你的朋友想要去你家的时候,你复刻了一把新钥匙给他,自己的还在自己手里,这就是值传递。这种情况下,他对这把钥匙做什么都不会影响你手里的这把钥匙。
    但是,不管上面那种情况,你的朋友拿着你给他的钥匙,进到你的家里,把你家的电视砸了。那你说你会不会受到影响?而我们在pass方法中,改变user对象的name属性的值的时候,不就是在“砸电视”么。
    还拿上面的一个例子来举例,我们真正的改变参数,看看会发生什么?

    public static void main(String[ ] args){
        ParamTest pt = new ParamTest();
        User hollis = new User();
        hollis.setName( "Hollis");
        hollis.setGender("Male" );
        pt.pass(hollis);
        system.out.println("print in main , user is " + hollis);
        public void pass(User user) {
            user = new User();
            user.setName( "hollischuang");
            user.setGender( "Male");
            system.out.println( "print in pass , user is " + user);
    
    

    上面的代码中,我们在pass方法中,改变了user对象,输出结果如下:

    print in pass , user is User{name='hollischuang ' , gender='Male '}
    print in main , user is User{name='Hollis', gender= 'Male '}
    

    我们来画一张图,看一下整个过程中发生了什么,然后我再告诉你,为啥Java中只有值传递。

    稍微解释下这张图,当我们在main中创建一个User对象的时候,在堆中开辟一块内存,其中保存了name和gender等数据。然后hollis持有该内存的地址ex123456(图1)。当尝试调用pass方法,并且hollis作为实际参数传递给形式参数user的时候,会把这个地址ex123456交给user,这时,user也指向了这个地址(图2)。然后在pass方法内对参数进行修改的时候,即user = newUser();,会重新开辟一块 eX456789的内存,赋值给user。后面对user的任何修改都不会改变内存eX123456的内容(图3)。
    上面这种传递是什么传递?肯定不是引用传递,如果是引用传递的话,在user=new User()的时候,实际参数的引用也应该改为指向eX456789,但是实际上并没有。
    通过概念我们也能知道,这里是把实际参数的引用的地址复制了一份,传递给了形式参数。所以,上面的参数其实是值传递,把实参对象引用的地址当做值传递给了形式参数。
    我们再来回顾下之前的那个“砸电视”的例子,看那个例子中的传递过程发生了什么。

    同样的,在参数传递的过程中,实际参数的地址eX1213456被拷贝给了形参,只是,在这个方法中,并没有对形参本身进行修改,而是修改的形参持有的地址中存储的内容。
    所以,值传递和引用传递的区别并不是传递的内容。而是实参到底有没有被复制一份给形参。在判断实参内容有没有受影响的时候,要看传的的是什么,如果你传递的是个地址,那么就看这个地址的变化会不会有影响,而不是看地址指向的对象的变化。就像钥匙和房子的关系。
    那么,既然这样,为啥上面同样是传递对象,传递的String对象和User对象的表现结果不一样呢?我们在pass方法中使用name = “hollischuang”;试着去更改name的值,阴差阳错的直接改变了name的引用的地址。因为这段代码,会new一个String,在把引用交给name,即等价于name =new String(“hollischuang”);。而原来的那个”Hollis”字符串还是由实参持有着的,所以,并没有修改到实际参数的值。

    所以说,Java中其实还是值传递的,只不过对于对象参数,值的内容是对象的引用。

    总结

    无论是值传递还是引用传递,其实都是一种求值策略(Evaluation strategy)。在求值策略中,还有一种叫做按共享传递。其实Java中的参数传递严格意义上说应该是按共享传递。

    按共享传递,是指在调用函数时,传递给函数的是实参的地址的拷贝(如果实参在栈中,则直接拷贝该值)。在函数内部对参数进行操作时,需要先拷贝的地址寻找到具体的值,再进行操作。如果该值在栈中,那么因为是直接拷贝的值,所以函数内部对参数进行操作不会对外部变量产生影响。如果原来拷贝的是原值在堆中的地址,那么需要先根据该地址找到堆中对应的位置,再进行操作。因为传递的是地址的拷贝所以函数内对值的操作对外部变量是可见的。

    简单点说,Java中的传递,是值传递,而这个值,实际上是对象的引用。
    而按共享传递其实只是按值传递的一个特例罢了。所以我们可以说Java的传递是按共享传递,或者说Java中的传递是值传递。

    所以函数内部对参数进行操作不会对外部变量产生影响。如果原来拷贝的是原值在堆中的地址,那么需要先根据该地址找到堆中对应的位置,再进行操作。因为传递的是地址的拷贝所以函数内对值的操作对外部变量是可见的。

    简单点说,Java中的传递,是值传递,而这个值,实际上是对象的引用。
    而按共享传递其实只是按值传递的一个特例罢了。所以我们可以说Java的传递是按共享传递,或者说Java中的传递是值传递。

    //本文借鉴于知乎Holis先生

    展开全文
  • 为什么Java只有值传递

    2021-01-20 02:08:46
    我们先看一下值传递和引用传递的概念和区别 值传递:是指在调用函数时将实际参数复制一份传递到函数中,...我们通过例子理解一下Java值传递: public static void main(String[] args) { int a = 10; int b = 20;
  • Java 值传递和引用传递

    千次阅读 2022-03-31 19:47:03
    值传递:在调用函数的时候,将实际参数复制一份传递到函数中,这样在函数中对参数进行修改的 时候,就不会影响到原来的实际参数 引用传递:在调用函数的时候,将实际参数的地址直接传递函数中,这样在函数中对参数进行修改...
    值传递:在调用函数的时候,将实际参数复制一份传递到函数中,这样在函数中对参数进行修改的
           时候,就不会影响到原来的实际参数
    引用传递:在调用函数的时候,将实际参数的地址直接传递函数中,这样在函数中对参数进行修改
           的时候,就会影响到实际参数
    
                  值传递                    引用传递
    根本区别    会创建一个副本(copy)        不创建副本
    结果        函数中无法改变原来的对象    函数可以改变原来的对象
    
    将对象创建好了之后将信息传给了函数
    在函数中对原来传入的值进行了改变,
    主函数中的对象的值也改变了.
    那么这里就是引用传递,并且所有的对象的地址都是相同
    只要有一个函数对其进行了改变,那么对象的值就变了
    java中的基本年数据类型都是值传递,引用数据类型中的String也是值传递
    引用数据类型除了String之外都是引用传递

    值传递

    package cn.java.Demo;
    
    /**
     * 通过运行结果我们知道,str的值发生了改变,但是s的值没有发生改变还是原来的值
     * 所有
     * String类型是一个值传递
     * 调用函数对String类型进行赋值的时候,   str = "哈哈哈哈"; 相当于做了一个创建
     * 对象的操作   str = new String("哈哈哈哈");
     * 这里我们可以理解为变量str重新创建了一个新的对象指向新的地址
     */
    public class Demo_02 {
        public void pass(String str){
            System.out.println("str === " + str.hashCode());
            str = "哈哈哈哈";
            System.out.println("str = " + str);
            System.out.println("str === " + str.hashCode());
        }
    
        public static void main(String[] args) {
            Demo_02 demo_02 = new Demo_02();
            String s = "呵呵呵";
            System.out.println("s === " + s.hashCode());
    
            demo_02.pass(s);
            System.out.println("s = " + s);
            System.out.println("s === " + s.hashCode());
        }
    }

    运行结果:

     引用传递

    先创建一个实体类:

    package cn.java.Demo;
    
    public class User {
        private String name;
        private Integer age;
    
        public User() {
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    /**
     * 将对象创建好了之后将信息传给了函数
     * 在函数中对原来传入的值进行了改变,
     * 主函数中的对象的值也改变了.
     * 那么这里就是引用传递,并且所有的对象的地址都是相同
     * 只要有一个函数对其进行了改变,那么对象的值就变了
     * java中的基本年数据类型都是值传递,引用数据类型中的String也是值传递
     * 引用数据类型除了String之外都是引用传递
     */
    public class Demo_03 {
        public void pass(User user){
            System.out.println("2     " + user.hashCode());
            user.setName("李四");
            user.setAge(20);
            System.out.println(user.toString());
            System.out.println("3     " + user.hashCode());
        }
    
        public static void main(String[] args) {
            Demo_03 demo_03 = new Demo_03();
            User user = new User("张三",18);
            System.out.println("1     " + user.hashCode());
            System.out.println(user.toString());
            demo_03.pass(user);
            System.out.println(user.toString());
            System.out.println("4     " + user.hashCode());
        }
    }

    运行结果:

     

    展开全文
  • 主要介绍了Java参数传递及值传递实现原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JAVA值传递还是引用传递?

    千次阅读 2022-03-12 14:20:28
    结论:java值传递,只是, 对于基本数据类型,传递的是基本类型的量值的拷贝 对于引用类型,传递的是该引用所指向的对象在内存中的地址值的拷贝 实参和形参 public static void test(String s){ System.out....
  • Java值传递问题分析解决

    千次阅读 2022-04-28 16:13:40
    Java值传递问题分析解决
  • Java 值传递与“引用传递”

    千次阅读 多人点赞 2020-02-09 14:23:35
    Java值传递2. Java 的引用传递 1. Java值传递 通常认为Java 方法传参数都是值传递 2. Java 的引用传递 传入引用类型的数据,可以修改数据内容,但是在方法中对传入引用的再赋值不会生效 ...
  • 首先我们来看下什么是值传递 package com.aozhi.test; //示例一:值传递 基本数据类型都是值传递,因为他们都存在栈里边 public class ValueDemo { public static void main(String[] args) { int x = 10; ...
  • Java:按值传递还是按引用传递详细解说
  • java 中没有引用传递,都是值传递的,可以通过传递副本修改对象的,副本交换,并不影响原引用
  • java值传递与引用传递

    2012-12-24 11:17:41
    不管是按值传递还是按引用传递,都是把栈中的数据备份了一份给参数变量,只不过值类型备份的是具体的数值,而引用类型备份的是内存地址
  • java中都是值传递,它是继承于c++但是移除出了很多难懂的语法, js也是值传递; 1.啥叫值传递啊: 顾名思义,就是值的传递,基本类型,引用类型,在创建出来,就是存在于当前方法所在的栈帧,就是调用其他方法,传的...
  • 与其他语言不同,Java不允许程序员选择按值传递还是按引用传递各个参数,基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。就对象而言,不是将对象本身传递给方法,而是将对象的...
  • 当一个变量为一个参数传入方法内部的时候,会有两种不同的传递方式:值传递和引用传递。  值传递的特点:不管方法内部对传进去的参数作任何改变,也不会影响方法外部的变量的值  引用传递的特点:方法内部对传...
  • java中的值传递和引用传递

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

    千次阅读 2017-05-21 10:53:12
    某坑公司的面试题如下 我认真了想想,这无非就是Java值传递和引用传递,利用反射是可以做到的 反射public static void doSomethingReflect(Integer a, Integer b) throws Exception { Field field = a.getClass...
  • Java值传递和引用传递

    千次阅读 2022-04-20 16:12:38
    Java值传递和引用传递 值传递:对形参的修改不会影响到实参 。引用传递:对实参的修改能够影响到实参 Java值传递:如果是基本数据类型,就是复制一份值传递给形参;如果是引用类型,那就将引用复制一份,传递给...
  • Java 值传递和对象传递详解

    千次阅读 2016-05-12 17:46:04
    堆和栈:Java中基本数据类型的和对象的引用保存在栈中,具体对象保存在堆中。传递原理: 一个方法传递的参数如果是基本数据类型,则是对具体的拷贝;如果是对象数据类型,则是对对象引用地址的拷贝,而非...
  • Java值传递还是引用传递

    千次阅读 2022-01-20 21:17:52
    Java值传递还是引用传递??? java中无论是基本类型还是引用类型,都是值传递
  • Java中是值传递和引用传递

    千次阅读 2022-01-15 12:22:33
    Java中只有值传递 首先回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。 按值调用(call by value):表示方法接收的是调用者提供的值。 按引用调用(call by reference):表示方法接收...
  • 快速区分值传递和引用传递
  • 形参和实参——Java值传递详细说明

    千次阅读 2021-06-10 09:48:38
    java只有值传递,方法上传的是引用对象的地址 因为java中方法的参数传递的原则是复制。也就是说不管是值传递还是引用传递,参数传递的都是值得拷贝或者是引用的拷贝。因此对象作为参数传递的是对象的引用 ...
  • java中什么是值传递

    千次阅读 2022-03-10 17:50:50
    如下图代码,输出后a和b的,以及张三李四会交换吗 我们直接给出结果: 结果一定是不会交换的 那么为什么他不会交换呢?我给大家画一下这段程序执行时堆栈的解析图 首先Main方法入栈,然后实例化a,b,...
  • Java值传递

    千次阅读 2021-08-12 21:47:31
    一、值传递和引用传递 ...Java是采用值传递的,Java程序中的方法得到的总是实参值的拷贝, 二、代码运行 我们来看下下面代码的运行结果 public class Main { public static void main(String[] args) { ...
  • Java值传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到值传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对...当然如果针对 Java 语言本身来讲,Java 中只有 值传递,没有...
  • Java到底是值传递还是引用传递?

    万次阅读 2022-05-13 16:37:56
    直接斩钉截铁地说Java值传递的有点不太合适,这里我给出自己的看法。 c语言的按引用传递 在C语言中是可以按引用传递的,我们可以在方法中接收外部参数,实参使用&地址符来表示需要按引用传递,这样我们在方法...
  • Java值传递和引用传递详细说明

    千次阅读 多人点赞 2020-07-14 15:53:17
    学过Java基础的人都知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运用却解释不出原理,而且坊间讨论的话题又是充满争议:有的论坛帖子说Java只有值传递,...
  • Java值传递的一些理解

    千次阅读 2020-06-08 17:09:12
    更何况,要想知道Java到底是传值还是传引用,起码你要先知道传值和传引用的准确含义吧?可是如果你已经知道了这两个名字的准确含义,那么你自己就能判断Java到底是传值还是传引用。 这就好像用大学的名词来解释高中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 673,923
精华内容 269,569
关键字:

java值传递