精华内容
下载资源
问答
  • java中的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。 java中的数据类型 Java中...

    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。

    java中的数据类型

    Java中数据类型分为两大类:基本类型和引用类型。相应的,变量也分这两种类型:基本类型和引用类型。

    基本类型的变量保存原始值,即它代表的值就是数值本身;

    而引用类型的变量保存的值是引用值,"引用值"指向内存空间的地址,代表了某个对象的引用,而不是对象本身,对象本身存放在这个引用值所表示的地址的位置。

    基本类型包括:byte,short,int,long,char,float,double,Boolean,returnAddress。

    引用类型包括:类、接口类型和数组。

    java中只有值传递

    在日常编码中,会经常看到如下现象:

    1、对于基本类型参数,在方法体内对参数进行重新赋值,不会改变原有变量的值。

    2、对于引用类型参数,在方法体内对参数进行重新赋予引用,不会改变原有变量所持有的引用。

    3、方法体内对参数进行运算,不会改变原有变量的值。

    4、对于引用类型参数,方法体内对参数所指向对象的属性进行操作,将改变原有变量所指向对象的属性值。

    举个例子:

    public class Main {
    
        private static void getMiddleOne(boolean b, Boolean boo, Boolean[] arr){
    
            b = true;
    
            boo = new Boolean(true);
    
            arr[0] = true;
    
        }
    
           //测试
    
        public static void main(String[] args) {
    
            boolean b = false;
    
            Boolean boo = new Boolean(false);
    
            Boolean[] arr = new Boolean[]{false};
    
            getMiddleOne(b, boo, arr);
    
            System.out.println(b);
    
            System.out.println(boo.toString());
    
            System.out.println(arr[0]);
    
            /**
    
            * output:
    
            * false
    
            * false
    
            * true
    
            */
    
        }
    
    }

    我们只要了解了下面两点就可以解答上面的现象了:

    1、基本数据类型的值就是数值本身,所以示例中的b的值就是false;包装类因为会自动装箱拆箱,所以可以和基本类型一样处理,所以示例中boo的值就是false;数组是引用类型,所以arr的值就是指向该Boolean[]的引用。

    2、java中只有值传递没有引用传递,所以传入getMiddleOne方法的三个参数分别是b的值拷贝, boo的值拷贝, arr的值拷贝。

    通过上面两点就可以清楚了,getMiddleOne方法中执行的 b=true 和 boo = new Boolean(true) 都是把新值赋给了他们的拷贝,所以不改变原变量的值;同样,arr[0] = true 是把true复制给了arr的拷贝所指向的数组的第一个元素,arr的值和arr的拷贝的值都是该数组的引用,所以arr的拷贝所指向的数组和arr所指向的数组是同一个,所以改变arr的拷贝的数组的元素会同样影响到原变量arr。

    总结

    java中只有值传递,基本类型传递的是值的副本,引用类型传递的是引用的副本。

     

    展开全文
  • Java对象值传递和对象传递的总结

    千次阅读 2017-03-17 16:41:42
    前两天项目lead面试我,问的第一个问题就是值传递对象传递的问题,这问题之前只知道皮毛,不是很清晰,今天专门总结下。 先看基本类型作为参数传递的例子: public class Test1 { public static void main...

    前两天项目lead面试我,问的第一个问题就是值传递和对象传递的问题,这问题之前只知道皮毛,不是很清晰,今天专门总结下。

    先看基本类型作为参数传递的例子:
    public class Test1 {
    public static void main(String[] args) {
    int n = 3;
    System.out.println("Before change, n = " + n);
    changeData(n);
    System.out.println("After changeData(n), n = " + n);
    }
    public static void changeData(int nn) {
    nn = 10;
    }
    }
    我想这个例子大家都明白,基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝,原值是不会改变的,输出的结果证明了这一点:
    Before change, n = 3
    After changeData(n), n = 3
    那么,我们现在来看看对象作为参数传递的例子,这也是大家争论的地方。
    public class Test2 {
    public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("Hello ");
    System.out.println("Before change, sb = " + sb);
    changeData(sb);
    System.out.println("After changeData(n), sb = " + sb);
    }
    public static void changeData(StringBuffer strBuf) {
    strBuf.append("World!");
    }
    }

    先看输出结果:
    Before change, sb = Hello 
    After changeData(n), sb = Hello World!

    从结果来看,sb的值被改变了,那么是不是可以说:对象作为参数传递时,是把对象的引用传递过去,如果引用在方法内被改变了,那么原对象也跟着改变。从上面例子的输出结果来看,这样解释是合理。
    现在我们对上面的例子稍加改动一下:
    public class Test3 {
    public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("Hello ");
    System.out.println("Before change, sb = " + sb);
    changeData(sb);
    System.out.println("After changeData(n), sb = " + sb);
    }
    public static void changeData(StringBuffer strBuf) {
    strBuf = new StringBuffer("Hi ");
    strBuf.append("World!");
    }
    }
    按照上面例子的经验:对象作为参数传递时,是把对象的引用传递过去,如果引用在方法内被改变了,那么原对象也跟着改变。你会认为应该输出:
    Before change, sb = Hello 
    After changeData(n), sb = Hi World!

    但运行一下这个程序,你会发现结果是这样的:
    Before change, sb = Hello 
    After changeData(n), sb = Hello

    这就是让人迷惑的地方,对象作为参数传递时,同样是在方法内改变了对象的值,为什么有的是改变了原对象的值,而有的并没有改变原对象的值呢?这时候究竟是“传值”还是“传引用”呢?

    下面就让我们仔细分析一下,来揭开这中间的奥秘吧。
    先看Test2这个程序:
    StringBuffer sb = new StringBuffer("Hello ");
    这一句执行完后,就会在内存的堆里生成一个sb对象.sb是一个引用,里面存放的是一个地址“@3a”(这个“@3a”是我举的代表内存地址的例子,你只需知道是个内存地址就行了),而这个地址正是“Hello ”这个字符串在内存中的地址。

    执行这一句后,就把sb传给了changeData方法中的StringBuffer strBuf,由于sb中存放的是地址,所以,strBuf中也将存放相同的地址,请看

    此时,sb和strBuf中由于存放的内存地址相同,因此都指向了“Hello”。
    strBuf.append("World!");

    执行changeData方法中的这一句后,改变了strBuf指向的内存中的值,

    所以,Test2 这个程序最后会输出:

    After changeData(n), sb = Hello World!

    再看看Test3这个程序。
    没有执行到changeData方法的strBuf = new StringBuffer(“Hi “);之前,对象在内存中的图和上例中“图2”是一样的,而执行了strBuf = new StringBuffer(“Hi “);之后,则变成了:

    此时,strBuf中存放的不再是指向“Hello”的地址,而是指向“Hi ”的地址“@3b” (同样“@3b”是个例子)了,new操作符操作成功后总会在内存中新开辟一块存储区域。
    strBuf.append("World!");

    而执行完这句后,

    Hi World!
    通过上图可以看到,由于sb和strBuf中存放地址不一样了,所以虽然strBuf指向的内存中的值改变了,但sb指向的内存中值并不会变,因此也就输出了下面的结果:
    After changeData(n), sb = Hello
    String类是个特殊的类,对它的一些操作符是重载的,如:
    String str = “Hello”; 等价于String str = new String(“Hello”);
    String str = “Hello”;
    str = str + “ world!”;等价于str = new String((new StringBuffer(str)).append(“ world!”));
    因此,你只要按上面的方法去分析,就会发现String对象和基本类型一样,一般情况下作为参数传递,在方法内改变了值,而原对象是不会被改变的。

    综上所述,我们就会明白,在Java中对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数。


    展开全文
  • 关于Java中的值传递我一开始是有点搞混的值传递表示传递的是调用者的值 引用调用表示传递的是调用者提供的变量地址所以重新再梳理一下package Test;public class Test { public static void main(String[] args){ ...

    关于Java中的值传递我一开始是有点搞混的

    值传递表示传递的是调用者的值
    引用调用表示传递的是调用者提供的变量地址

    所以重新再梳理一下

    package Test;
    
    public class Test {
    
        public static void main(String[] args){
            Test test = new Test();
            Student stu_a = test.new Student("Bob");
            Student stu_b = test.new Student("Jerry");
    
            double regular = 86; //平时成绩
            double examining = 90; //考试成绩   
            System.out.println("\nTest1--------------------------------------------------");
            System.out.println("Before regualr, examining: "+regular+", "+examining);
            stu_a.setGrades(regular, examining);
            System.out.println("After regualr, examining: "+regular+", "+examining);
    
            System.out.println("\nTest2--------------------------------------------------");
            System.out.println("Before stu_a Grades: "+stu_a.getGrades());
            Awarded(stu_a);
            System.out.println("After stu_a Grades: "+stu_a.getGrades());
    
            System.out.println("\nTest3--------------------------------------------------");
            System.out.println("Before stu_a = "+stu_a.getName());
            System.out.println("Before stu_b = "+stu_b.getName());
            swap(stu_a, stu_b);
            System.out.println("After stu_a = "+stu_a.getName());
            System.out.println("Bfter stu_b = "+stu_b.getName());
    
    
        }
    
        public static void swap(Student x, Student y){
            Student temp = x;
            x = y;
            y = temp;
            System.out.println("方法结束 x = "+x.getName());
            System.out.println("方法结束 y = "+y.getName());
        }
    
        public static void Awarded(Student x){
            x.add(20);
            System.out.println("方法结束Grades: "+x.getGrades());
        }
    
        class Student{
            private String name;
            private double grades;
    
            Student(String name){
                this.name = name;
            }
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public double getGrades() {
                return grades;
            }
    
            public void setGrades(double x, double y) {
                x *= 0.3;
                y *= 0.7;
                System.out.println("方法结束 x,y:"+x+", "+y);
                grades= x + y;
            }
    
            public void add(double awarded){
                grades += awarded;
            }
        }
    }
    

    测试结果如下:
    这里写图片描述

    测试一、

    double regular = 86; //平时成绩
    double examining = 90; //考试成绩   
    ......
    stu_a.setGrades(regular, examining);
    ......
    public void setGrades(double x, double y) {
                x *= 0.3;
                y *= 0.7;
                System.out.println("方法结束 x,y:"+x+", "+y);
                grades= x + y;
            }

    不必理睬这个方法的具体实现,在方法调用后regular还是86,examining还是90
    其中具体执行过程是这样的:
    1、x被初始化为regular值的一个拷贝
    2、x = x*0.3
    3、这个方法结束后,参数变量x不再使用,会被回收
    4、y亦同理。
    这里写图片描述

    所以从头到尾regular变量都没有改变,传入的参数是它的一个拷贝。这个是值传递。

    测试二

    ...
    Student stu_a = test.new Student("Bob");
    ...
    Awarded(stu_a);
    ...
    public static void Awarded(Student x){
            x.add(20);
            System.out.println("方法结束Grades: "+x.getGrades());
        }

    从结果可以看到,传入对象stu_a,调用Awarded方法,stu_a的Grades值被改变了。
    难道对象采用的就是引用传递吗?
    不是!
    看看具体执行的过程:
    1、x被初始化为stu_a值的拷贝,x也指向Student对象,这里是一个对象的引用
    2、add()方法应用于这个对象的引用,
    3、方法结束后,参数变量x不再使用,回收。

    这里写图片描述

    之所以这里grades会改变,是因为调用new出来的这个Student对象add()方法,里面的grades被改变了。

    接下来测试三、

     Student stu_a = test.new Student("Bob");
     Student stu_b = test.new Student("Jerry");
     ...
     swap(stu_a, stu_b);
    
    public static void swap(Student x, Student y){
            Student temp = x;
            x = y;
            y = temp;
            System.out.println("方法结束 x = "+x.getName());
            System.out.println("方法结束 y = "+y.getName());
        }
    

    最后结果看来,他们并没有交换!!!
    来看看具体的执行过程:
    1、swap方法的参数x和y被初始化两个对象引用的拷贝
    2、x、y进行交换
    3、方法结束,x、y不再使用,被回收。

    交换前

    这里写图片描述

    交换后

    这里写图片描述

    所以至始至终都是x、y在交换,stu_a和stu_b没有交换

    所以Java对象也是采用值传递的方式的。

    展开全文
  • Java值传递还是引用传递

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

        最近整理面试题,整理到值传递、引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对你有所帮助。
        首先说下我的感受,这个题目出的很好,但是在 Java 中这个题目是有问题的(在下面我会解释)。并且,有很多结论是 Java 中只有 值传递。我认为这样说不够严谨。当然如果针对 Java 语言本身来讲,Java 中只有 值传递,没有引用传递,是正确的。但是如果针对 值传递,引用传递定义来说,Java 中还是有引用传递的。下面来分析:

    一、值传递、引用传递定义


        在深入分析问题之前,先让初问者简单明白一下什么是值传递,引用传递。我先用 Java 代码解释:

    public class StringBase {
    
        public static void main(String[] args) {
            int c = 66; //c 叫做实参
            String d = "hello"; //d 叫做实参
    
            StringBase stringBase = new StringBase();
            stringBase.test5(c, d); // 此处 c 与 d 叫做实参
    
            System.out.println("c的值是:" + c + " --- d的值是:" + d);
        }
        
        public void test5(int a, String b) { // a 与 b 叫做形参
            a = 55;
            b = "no";
        }
    }


    【运行结果】
    c的值是:66 --- d的值是:hello

    可以看出通过方法传递后,int 类型与 String 类型的原值并没有受到前面 test5 方法执行后的影响,还是输出了原值。这种形为通常被说成值传递。如果原值经过 test5 方法后被改变了,这种形为通常被描述为引用传递

    定义

        值传递:指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
        引用传递:是指在调用函数时将实际参数的地址直接传递到函数中(的形参),那么在函数中对参数所进行的修改,将影响到实际参数。
        引用传递:形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作。(下面文章中 C++ 的定义,我觉得这样说更精简形象一些,所以放了两个定义,其实意思是一样的)

        以上,就是相关的定义,大家对这个定义几乎没有分歧,但是我建议大家,有必要去看看 C++ 中 值传递、引用传递的定义。因为在 C++ 中有三个定义:值传递、引用传递、指针传递,推荐一个地址: C++ 值传递、指针传递、引用传递详解

    //引用传递
    void change2(int &n) {
        cout << "引用传递--函数操作地址" << &n << endl;
        n++;
    }

        我们看上边 C++ 引用传递的代码,使用的 & 操作符。& 操作符在 C++ 中被定义为"引用",引用在 C++ 中的定义是“引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样”,再看引用其中的一个描述:“声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元”。因此这引用的概念在 Java 中根本不存在。Java 中哪有给变量起个别名的!!!
        因此说,这个题出的就有问题,在 Java 官方中我一直没有找到明确的证据说“Java 中 值传递、引用传递 的定义”我所看到的全是说 C++ 中关于值传递、引用传递的定义。但是,在 Java 中没有 C++ 里"引用"的概念。Java 里只有对象,new 关键字。这就很尴尬了,拿 C++ 中的定义,来解释 Java,我觉得这就是有问题的。问题就出在了引用传递!!!
        在 C++ 中关于引用传递的定义明确,代码解释清晰。在 C++ 中引用传递,传递的是一个别名,操作别名就跟操作原值一个样。
        然而在 Java 中,没有引用的概念,Java 中只要定义变量就会开辟一个存储单元。因此,对 Java 语言来说只有值传递,没有引用传递是正确的。
        虽然 Java 中没有引用(C++ 中 引用"&")。但是,引用传递的定义,在 Java 中还是有符合条件的。抛开语言中的特性。只针对:值传递、引用传递的定义我们来分析一下,Java 是属于值传递还是引用传递。
        要想知道 Java 是属于值传递还是引用传递,这就要从 Java 内存模型聊起了,我们来看基本数据类型与引用类型在内存中的存储方式。

    二、基本数据类型、引用类型

    1.基本数据类型、引用类型定义
        基本数据类:Java 中有八种基本数据类型“byte、short、int、long、float、double、char、boolean”
        引用类型:new 创建的实体类、对象、及数组
    2.基本数据类型、引用类型在内存中的存储方式
        基本数据类型:存放在栈内存中。用完就消失。
        引用类型:在栈内存中存放引用堆内存的地址,在堆内存中存储类、对象、数组等。当没用引用指向堆内存中的类、对象、数组时,由 GC回收机制不定期自动清理。
    3.基本类型、引用类型内存简单说明图


        好,看了基本的内存图,应该能明白 Java 是属于值传递还是引用传递。不明白,也没关系,下面会详细说明,先说引起争议的代码。

    三、在 Java 中 值传递 与 引用传递,产生模糊不清的代码

    public class TransmitTest {
    
        public static void main(String[] args) {
    
            String a = "hello"; //String 引用数据类型,调用 pass 方法后 b 的值没有改变,不是 hello
            int b = 1; //int 基本数据类型,调用 pass 方法后 a 的值没有改变,还是 1
    
            User user = new User(); //new Class 引用类型,调用 pass 方法后 name 与 age 的值改变了
            user.setName("main"); // 调用 pass 后,name 为 pass 了
            user.setAge(2); //调用 pass 后,age 为 4 了
    
            pass(user, a, b); //pass 方法调用
    
            System.out.println("main 方法 user 是:" + user.toString());
            System.out.println("main 方法 a 的值是:" + a + " --- b 的值是:" + b);
        }
    
        public static void pass(User user, String a, int b) {
    
            a = "你好";
            b = 3;
    
            user.setName("pass");
            user.setAge(4);
    
            System.out.println("pass 方法 user 是:" + user.toString());
            System.out.println("pass 方法 a 的值是:" + a + " --- b 的值是:" + b);
        }
    }
    
    class User {
    
        String name;
        int 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 "name = " + name + " --- age = " + age;
        }
    }

    【运行结果】
    pass 方法 user 是:name = pass --- age = 4
    pass 方法 a 的值是:你好 --- b 的值是:3
    main 方法 user 是:name = pass --- age = 4
     

        main 方法 a 的值是:hello --- b 的值是:1    结果分析,int b,实参是 1,pass 方法调用后,值还是 1 没变,说明基本数据类型是值传递,大家对这个也几乎没争议。
    争议的在下边了:
            1.String a 是引用类型,pass 方法调用后,值还是 hello 没变。(结论:好像引用类型也是值传递啊!!!)
            2.new User() 也是引用类型,在方法调用后,值居然变了。原值不应该是 name = main,age = 2 的吗?为什么 name = pass,age = 4 了呢?(结论:引用类型好像是引用传递啊???)
        这就奇葩了,String 与 new 创建的类,同为引用类型,为什么产生的结果不一样呢?String 不也是一个类吗?User 不也是一个类吗?
        有人解释说这个代码比喻的不对,应该用如下代码比喻,在 pass 方法中添加一行代码,user = new User(),pass 方法修改如下:

    public static void pass(User user, String a, int b) {
    
        a = "你好";
        b = 3;
    
        user = new User();
        user.setName("pass");
        user.setAge(4);
    
        System.out.println("pass 方法 user 是:" + user.toString());
        System.out.println("pass 方法 a 的值是:" + a + " --- b 的值是:" + b);
    }


    【运行结果】
    pass 方法 user 是:name = pass --- age = 4
    pass 方法 a 的值是:你好 --- b 的值是:3
    main 方法 user 是:name = main --- age = 2
    main 方法 a 的值是:hello --- b 的值是:1

        这样一来,改变了形参的值,但是实参没有改变。因此有人得出结论,Java 中只有值传递,没有引用传递。(我并不这么认为,原因如下)
        使用 user = new User() 这个代码来做验证,我觉得是符合 String 类型做形参时的验证地,但是,此示例不符合引用传递的验证
        在验证之前,我们先看下使用 user=new User(); 语句之前与之后的内存模型图,能有助于我们更好的验证结果,同时也有助于更好的理解 Java 内存模型。我们看 TransmitTest 类在 Java 内存模型中的存储图:

    图1 pass() 方法中没有使用 user=new User() 语句的内存模型图


        在 图1 中,main() 方法中的 user 类,与 pass() 方法中的 user 类,指向的是同一个堆内存中的 User 类,红色虚线是在 main() 方法中初次给 name 属性赋的值"main"。实线部分,是在 pass() 方法中给 name 属性赋的值"pass"。因为在堆内存中只有一个 User 类实体,因此 main() 方法与 pass() 方法中的 user 指向的都是同一个 User 类 0x000031。因此,无论在 main() 方法还是 pass() 方法中,改变其 user 的属性值后,打印 User 类的属性值肯定是一样的,他们用的是一个实体类。

    图2 pass() 方法中使用了 user=new User() 语句的内存模型图


        在 图2 中,main() 方法中的 user 类首次加载,堆内存开辟了一个地址为 0x000031 的 User 类实体。当把 main() 方法中的实参 user 传递给 pass() 方法中形参 user 的时候,栈内存在 pass() 方法区中开辟了一个空间,并引用了地址为 0x000031 的 User 类。此时两个方法中的 User 类其实是一个。
        然而当 pass() 方法中的 user=new User()语句执行后,堆内存中新开辟了一个地址为 0x000032 的 User 类,pass() 方法中的 user 从此指向了地址为 0x000032 的 User 类。
        因为 pass() 方法 与 main() 方法中的 user 属性分别指向了不同的 User 类,所以两个方法中的 User 类的属性无论怎么修改,相互都不影响。
        但是,这种操作是不能验证引用传递定义的。因为实参传值给形参后,形参自己改变了地址,这就和引用传递无关了。我们再来用代码验证。
        我们可以使用 C++ 引用传递代码来验证,使用 user = new User() 语句验证引用传递的错误性
    C++ 中引用传递代码

    class User
    {
    public:
        int age;   // 长度
        string name;  // 宽度
    };
    
    
    //引用传递
    void pass(User &user) {
    
        cout << "引用传递 -- user的地址是:" << &user << endl;
    
        user.age = 2;
        user.name = "你好";
    }
    
    
    int main() {
    
        User user;
        user.age = 1;
        user.name = "hello";
    
        cout << "实参 -- user的地址是:" << &user << endl;
        pass(user);
        cout << "实参 -- user的值 age=" << user.age << ",name=" << user.name << endl;
    
        system("pause");
        return false;
    }


    【运行结果】
    实参 -- user的地址是:00DCF768
    引用传递 -- user的地址是:00DCF768
    实参 -- user的值 age=2,name=你好

        在 C++ 中,引用传递的实参与形参地址一致,在引用的方法中,使用的就是实参的地址。当修改形参值后,实参值也跟着变。现在我们按照 user=new User(); 的方法改变一下引用方法 pass 如下:

    //引用传递
    void pass(User &user) {
    
        cout << "引用传递 -- user的地址是:" << &user << endl;
    
        User user2 = user; //相当于 Java 中的 user=new User();
        cout << "引用传递 -- user2的地址是:" << &user2 << endl;
    
        user2.age = 2;
        user2.name = "你好";
    }


    【运行结果】
    实参 -- user的地址是:00CFFACC
    引用传递 -- user的地址是:00CFFACC
    引用传递 -- user2的地址是:00CFF9AC
    实参 -- user的值 age=1,name=hello

        我们看,改变引用传递中形参 user 的地址后(后期改变的地址,这跟引用传递,值传递还有什么关系?),再修改形参 user 的值,实参没有任何变化。这就破坏了引用传递的场景,因此不能使用 user=new User(); 语句来验证引用传递的定义。

        排除了其他异议,我们再来分析 Java 中有没有引用传递。

    先把引用传递的定义放上

        引用传递:是指在调用函数时将实际参数的地址直接传递到函数中(的形参),那么在函数中对参数所进行的修改,将影响到实际参数。
        引用传递:形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作。

        经过上面的长篇大论,我想这时候你应该能明白了。在对引用类型做方法传递的时候,是不是先把实参的地址给形参的?之后对形参的操作是,是不是相当于操作实参?最后有没有影响到实际参数?
    答案肯定都是有的。

    定义关键1:是指在调用函数时将实际参数的地址直接传递到函数中(给形参了)
        证明:Java 在进行方法调用传递引用类型参数的时候,就是先给形参一个与实参相同的地址的(此处与 C++ 的不同之处是,C++ 是别名,没有在内存中给形参开辟空间,而 Java 给形参开辟了一个栈内存空间,存放与实参相同的引用地址。但是这与引用传递的定义不违背啊!!!定义可没说形参是否有开辟空间的概念)。

    定义关键2:在函数中对参数所进行的修改,将影响到实际参数。
        证明:Java 在进行方法调用传递引用类型参数后,修改形参的内容后,就是影响了实参的值。

    四、String 与包装类的特殊分析

        好了,解决了实例对象,我们再来说 String 与包装类,为什么 String 与包装类作为引用类型,却有值传递的功能,居然没有影响到实参!

    原因如下
        我们都知道。String 类型及其他七个包装类,是一群特殊群体。当使用 String a = "hello"; 语句时,相当于执行了 String a = new String("hello")。然而在 Java 中每一次 new 都是一次对象的创建。如果你创建的对象在堆中不存在,便会创建一个,如果是新创建的对象,那么地址都会变的,后期改变的地址,这跟引用传递,值传递还有什么关系?

        其实 String 型方法参数传值的过程,可以用以下代码来解释,我们先看 String 类型的还原:

    String a = "hello"; //a 相当于实参
    String a1 = a; //a1 就相当于形参
    a1 = "你好";
    System.out.println("a是:" + a + " --- a1是:" + a1);


    【运行结果】
    a是:hello --- a1是:你好

    逐步还原解释:
        String a = "hello"; 在 String 池中检查并创建一个常量:"hello",给 a 分配一个栈内存,在此存储常量 hello 的地址。
        String a1 = a; 给 a1 分配一个栈内存,在此存储常量 hello 的地址。相当于 a 把自己持有的地址,复制给了 a1。

    内存图如下


        a1 = "你好"; 等同于 a1 = new String("你好")。在 String 池中检查是否有 "你好" 的常量。如果有,将 a1 的地址指向 "你好" 的地址。如果 String 池中没有 "你好" 常量,在堆内存中创建 "你好" 常量,并将 a1 地址指向 "你好"。

    内存图如下


        总结如下:String 类型,在进行方法传参的时候,是先将实参地址,赋值给形参(形参在栈内存中确实新开辟了一个新的内存空间,用于存储地址)。但是当再次给 String 类型的形参赋值(与实参内容不一样的值时),形参地址变了,这就和引用传递无关了。我们可以用 C++ 代码中的引用传递,来验证 String 型的这一特殊情况,代码如下:

    //引用传递
    void pass(string &a, int &b) {
    
        cout << "引用传递 -- a的地址是:" << &a << " --- b的地址是:" << &b << endl;
        cout << "引用传递 -- a的值是:" << a << " --- b的值是:" << b << endl;
    
        string c = a; // 相当于 java 中的 new String
        int e = b;
    
        cout << "引用传递 -- c的地址是:" << &c << " --- e的地址是:" << &e << endl;
        cout << "引用传递 -- c的值是:" << c << " --- e的值是:" << e << endl;
    
        c = "你好"; //在引用传递中改变形参地址后做修改操作,不影响实参
        e = 2; //在引用传递中改变形参地址后做修改操作,不影响实参
    }
    
    int main() {
        string a = "hello";
        int b = 1;
    
        cout << "实参 -- a的地址是:" << &a << " --- b的地址是:" << &b << endl;
    
        pass(a, b);
    
        cout << "实参 -- a的值是:" << a << " --- b的值是:" << b << endl;
    
        system("pause");
        return false;
    }


    【运行结果】
    实参 -- a的地址是:00CFF9CC --- b的地址是:00CFF9C0
    引用传递 -- a的地址是:00CFF9CC --- b的地址是:00CFF9C0
    引用传递 -- a的值是:hello --- b的值是:1
    引用传递 -- c的地址是:00CFF8A0 --- e的地址是:00CFF894
    引用传递 -- c的值是:hello --- e的值是:1
    实参 -- a的值是:hello --- b的值是:1

        我们看,在 C++ 中的引用传递方法中,改变形参的地址后做修改操作,照样不影响实参的值,这就破坏了引用传递的本质,不能这样比喻。

        因此,String 与其他包装类,在做形参的时候,由于他们在赋不同于实参的值时,改变了形参的地址,因此使引用传递,看起来像值传递,其实本质还是引用传递。


    五、总结


    1.这个题目出的不严谨,但是很好(因为涉及了 Java 内存模型)
    2.就 Java 语言本身来说,只有值传递,没有引用传递。
    3.根据 值传递,引用传递的定义来说:
            Java 中的基本类型,属于值传递。
            Java 中的引用类型,属于引用传递。
            Java 中的 String 及包装类,属于特殊群体,作为形参时,由于每次赋值都相当于重新创建了对象,因此看起来像值传递,但是其特性已经破坏了,值传递、引用传递的定义。因此他们属于引用传递的定义,却表现为值传递。

    此题争议很大,我仅分享自己的理解,如有不同结论,欢迎指正,一起共勉!

    展开全文
  • JAVA】 什么是值传递和引用传递?

    万次阅读 多人点赞 2019-06-04 11:10:05
    值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 一般认为,java内的基础类型数据传递是值...
  • java对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递;引用类型,地址值传递,所以叫值传递。  当主函数的变量,对象(主本)传递到副函数时,传递的...
  • Java 值传递对象传递详解

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

    千次阅读 多人点赞 2019-12-11 08:43:27
    在逛 Stack Overflow 的时候,发现了一些访问量像阿尔卑斯山一样高的问题,比如说这个:Java 到底是值传递还是引用传递?访问量足足有 188万+,这不得了啊!说明有很多很多的程序员被这个问题困扰过。实话实说吧,我...
  • Java中String是值传递

    千次阅读 2018-01-06 11:08:13
    注意,这里的值传递意思是传递的是指向引用所指向对象在堆中地址值,而不是引用自身在堆栈中地址值。 下面是String值传递示例: public class Test { private static void change(String str){//这里的引用str...
  • java对象值传递和对象传递的总结

    万次阅读 多人点赞 2012-08-16 21:32:22
    前两天项目lead面试我,问的第一个问题就是值传递对象传递的问题,这问题之前只知道皮毛,不是很清晰,今天专门总结下。  先看基本类型作为参数传递的例子: public class Test1 { public static void main...
  • java对象作为参数传递一般是引用传递,基本变量传值方式是值传递。但是字符串作为一个对象传递却意外的是值传递。 先定义值传递意义:就是讲原先的基本变量或者引用拷贝一份,作为参数传递给函数。特点是当函数...
  • 在解决这个问题之前首先得说说Java对象在内存中的存储机制。 我们知道Java数据类型基本分为两种,一是基本类型,还一种是引用类型。 基本类型: 对象类型是固定的,如下: byte,short,int,long,float,double,...
  • 背景: 做项目的时候,将一个空对象的引用传入到方法中,期待方法里面创建一个新的对象给这个引用,后面就可以拿着这个对象用了。  可结果就是,定义在外面的对象引用并没有拿到这个引用 demo.java ...
  • JAVA是引用传递还是值传递

    千次阅读 2017-10-19 11:34:42
    那么java到底是值传递还是引用传递呢? 对于初学者或者说没有仔细思考过的同学来说这个概念即使知道了也没有很明确的答案!(ps:哈哈 至少我当初就是这样的 ,现在想想写下来和大家交流学习学习) 举个例子...
  • Java中是引用传递还是值传递

    千次阅读 多人点赞 2016-10-23 00:01:41
    - **值传递:**将方法实际参数值复制到另一个变量,然后复制的对象被传递,这就是为什么它被称为“值传递”- **引用传递:**将实际参数的引用传递给该方法,这就是为什么它被引用称为“传递”的原因。 例子分析1问题:...
  • 关于java对象的参数传递过程中,确实有些烦乱,在这里做一下总结:首先是一段测试代码 public class Main {    public class AA{  public String i;  public int j;  }  public static void ...
  • Java方法传递参数是值传递,但是在传递对象的引用的时候,引用的值就是对象实际在堆内存的地址
  • Java值传递和引用传递详细说明

    千次阅读 2020-07-14 15:53:17
    学过Java基础的人知道:值传递和引用传递是初次接触Java时的一个难点,有时候记得了语法却记不得怎么实际运用,有时候会的了运用却解释不出原理,而且坊间讨论的话题又是充满争议:有的论坛帖子说Java只有值传递,...
  • 还有的人可能知道Java中的参数传递是值传递,但是说不出来为什么。 在开始深入讲解之前,有必要纠正一下大家以前的那些错误看法了。如果你有以下想法,那么你有必要好好阅读本文。 错误理解一:值传递和引用传递,...
  • Java到底是值传递?还是引用传递?

    千次阅读 2016-02-17 14:23:43
    前言 最近和同事讨论算法效率问题无意中涉及到一个问题,java中调用方法的时候是值传递呢?...值传递是指将该值复制一份出来使用,比如a复制一份a1出来,a1做的操作不会影响到a。例子如下: public sta
  • java学习——java值传递和按址传递

    千次阅读 2017-02-09 14:17:27
    java中的按值传递和按址传递(按引用传递),要明白这两个概念,要理解按值和按址。
  • 面试官:兄弟,说说Java到底是值传递还是引用传递

    千次阅读 多人点赞 2020-04-23 11:24:00
    二哥,好久没更新面试官系列的文章了啊,真的是把我等着急了,所以特意过来...这不,又有两个读者不约而同地要求我更新一下 Java 到底是值传递还是引用传递方面的文章——其实这个问题我之前是写过的,但现在看起来...
  • Java 方法参数的值传递和引用传递

    千次阅读 2016-02-10 10:58:10
    Java 方法参数的值传递和引用传递在Java中,实际上值传递,并不存在引用传递。人们所说的引用传递,实则为指针间地址的传递。要理解此,我们必须明白一个概念,形如Object o;这样的定义,实际上我们在定义一个...
  • 对于非对象类型,java 参数传递值传递, 比如int. java 会直接复制一份值到方法参数里面去使用。 而对于对象类型,java 参数传递的是对象的引用,相当于对象在堆里面的内存地址。 我们分析下一下代码: public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 447,760
精华内容 179,104
关键字:

java对象都是值传递

java 订阅