Java call by value 和 by reference （值传递和引用传递）

最新推荐文章于 2024-05-24 16:59:43 发布
最新推荐文章于 2024-05-24 16:59:43 发布
阅读量7.2k 收藏 11
点赞数 4
分类专栏： 每日一水 java基础 文章标签： java 值传递-引用传递 java基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenfengbao/article/details/65626680
版权

关于JAVA中参数传递问题有两种，一种是按值传递（如果是基本类型），另一种是按引用传递（如果是對象）.

首先以两个例子开始：

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午8:37:04 
 *  
 */


public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer("A");
        StringBuffer b = new StringBuffer("B");
        operate(a,b);
        System.out.println(a+","+b);//AB,B
    }
    static void operate(StringBuffer x,StringBuffer y){
        x.append(y);
        y=x;
    }

}

输出：AB,B
Test2

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午8:42:09 
 *  
 */
public class Test2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Integer i = new Integer(0);
        add3(i);
        System.out.println(i.intValue());//0

    }

    private static void add3(Integer i) {
        // TODO Auto-generated method stub
        int val = i.intValue();
        val += 3;
        i = new Integer(val);
    }

}

输出：0

首先我们应该明白JAVA中的参数传递全是以值传递的。是基本类型，就拷贝一个基本类型传进方法；是引用，就拷贝一个引用变量传进去方法，理解了这 两点就能理解方法操作对象的相关问题了。最好能画出引用指向对象的图出来，就能完全理解了。
第1题，调用operate方法时，传入了两个引用a,b的拷贝x,y，这两个x,y都指向原a,b引用所指向的对象。x.append(y)对它指向的 对象(即a指向的对象)进行了操作。而x=y，只是两个拷贝变量在赋值，并没有影响到原b所指向的对象。所以b所指向的对象仍然为B。
第2题，i=new Integer(val)只是一个引用的拷贝指向了另外一个对象，而原来的i仍然是指向对象new Integer(0)的。
把握住了JAVA都是传值并且传的都是拷贝的话，类似的题大家都能迎刃而解了。

Java中的参数传递只有一种方式: by value. 理论说教太麻烦了，直接看些例子吧:
1). 基本类型

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午8:46:11 
 *  
 */
public class Test3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int x = 1;
        System.out.println(x);//1
        test(x);
        System.out.println(x);//1-------->by value


    }

    private static void test(int x) {
        // TODO Auto-generated method stub
        x = 2;

    }

}

2). 引用类型

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午8:48:00 
 *  
 */
public class Test4 {
    public static void main(String[] args) {
        Integer  x = new Integer(1);
        System.out.println(x);//    1
        test(x);
        System.out.println(x);//    1
    }

    private static void test(Integer x) {
        // TODO Auto-generated method stub
        x = new Integer(2);
    }

}

理解这里的关键是区分对象和引用。 这里声明的x是一个引用，而不是一个对象（只是Java把它设计为看上去好像是对象一样）。这个引用它指向了一个对象，这个对象就是后面用new关键字生 成的对象。因此，可以说x指向了一个Integer对象。
在调用test方法的时候，程序将x作为参数传递给test方法了。这里仍然是值传递，在test调用过程中，会产生一份新的引用(不妨叫做y)。此 时，x和y指向了同一个对象。
x和y指向的是同一个对象， 由于Java的设计，我们可以通过操作引用来达到操作对象的目的。因此，如果我们此时使用y来修改对象的属性 (例如，y.someField++); 你可以看到x指向的对象同时也被修改到了。
另一方面，如果我们让y指向另外一个对象， y=new Integer(2); 此时x和y就指向了不同的
对象。y修改了它指向的对象的属性，很显然不会影响到x指向的对象。

有人说了数组。数组也是一个引用类型，它的参数传递方式按照引用类型的参数传递一样可以解释得通：

package com.whf.ByValue_ByReference;

import java.util.Arrays;

/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午8:50:06 
 *  
 */
public class Test5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] aa = {3,2,1};
        System.out.println(Arrays.toString(aa));//[3, 2, 1]
        test(aa);
        System.out.println(Arrays.toString(aa));//[3, 2, 1]
        test2(aa);
        System.out.println(Arrays.toString(aa));//[4, 2, 1]
    }
     static void test2(int[] aa) {
        // TODO Auto-generated method stub
        if (aa!=null && aa.length>0) {
            aa[0]++;    //修改原来对象
        }
    }
    static void test(int[] a){
        a = new int[]{11,12,13};//  指向了新对象
    }

}

对象是传引用(call by reference)，简单类型是传值(call by value)，不要被网上的一些概念所迷惑！！！你可以自己做个试验。
至于String等类型传的还是引用。如果你用concat方法，String对象的原值就会被改变。
但你如果按如下方法：

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午9:02:01 
 *  
 */
public class Test6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "Hello";
        test(str);
        System.out.println(str);    //Hello

    }

    private static void test(String str) {
        // TODO Auto-generated method stub
        str = "World";
    }

}

　　运行结果：Hello
这里str = “World” 就等同于 String str＝new String(“World”)。所以结果没有改变！！！
下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？

package com.whf.ByValue_ByReference;

import java.util.ArrayList;
import java.util.List;

/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午9:04:11 
 *  
 */
public class Test7 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List list = new ArrayList();
        test2(list);
        System.out.println(list.size());//1处    (输出0)
        test3(list);
        System.out.println(list.size());//2处    (输出1)

    }

    private static void test3(List list) {
        // TODO Auto-generated method stub
        list.add("aaaaa");
    }

    private static void test2(List list) {
        // TODO Auto-generated method stub
        list = null;
    }

}

plumechen:

不会出错的。结果是0，1。

因为test2(list)传得是list的引用，我理解成指针置的副本，list=null；只是把那个传入的值设置为null，不改变原来 list的指针和内容。test3(list)传入的一样，但是执行了list.add()由于传入指针值的副本也指向原来的那个list的地址，所以原 来的那个list的内容就改变了，size变成了1了

　6．下列正确的有（）

　　A． call by value不会改变实际参数的数值

　　B． call by reference能改变实际参数的参考地址

　　C． call by reference不能改变实际参数的参考地址

　　D． call by reference能改变实际参数的内容

　　答案：ACD

Java中的参数传递只有一种方式: 值传递 （by value）

1、简单类型类型，在调用的方法中，直接是实参的一个拷贝

2、对象：程序将对象x作为参数传递给方法了。这里仍然是值传递，在方法调用过程中，会产生一份新的引用(不妨叫做y)。此时，x和y指向了同一个对象。

我们可以通过操作引用来达到操作对象的目的。 因此，如果我们此时使用y来修改对象的属性 (例如，y.someField++); 你可以看到x指向的对象同时也被修改到了。(值传递，在方法里产生引用，操作引用达到操作对象。所以引用可以修改实参（对象）的内容)
实验

package callbyvalue;

//public class Test2 {
//
//    public static void main (String [] args) {
//    StringBuffer a = new StringBuffer ("A");
//    StringBuffer b = new StringBuffer ("B");
//    operate (a,b);
//    System.out.println(a+","+b);          //AB,B
//    }
//
//    static void operate(StringBuffer x, StringBuffer y){  //JAVA中的参数传递全是以值传递的。
//        //是基本类型，就拷贝一个基本类型传进方法；是引用，就拷贝一个引用变量传进去方法
//         x.append(y);  //x.append(y)对它指向的对象(即a指向的对象)进行了操作
//         y = x;    //只是两个拷贝变量在赋值      并不会影响原来的对象
//         System.out.println(y);    //AB
//       }
//    }


//public class Test2 {
//
//    public static void add3 (Integer i){
//          int val=i.intValue();
//          val += 3;
//          i = new Integer (val);  //只是一个引用的拷贝指向了另外一个对象，而原来的i仍然是指向对象new Integer(0)的
//    }
//
//    public static void main (String args [ ] ) {
//    Integer i = new Integer (0);
//    add3 (i);
//    System.out.println (i.intValue ( ));  //0
//    }
//    }

我的实验

//public class Test2 {  //我的实验
//
//    public static void change (int i){
//        i=6;           //给拷贝赋值，并没有改变a指向的值
//    }
//
//    public static void main (String args [ ] ) {
//    int a=5;
//    change(a);
//      System.out.println (a);  //5   JAVA都是传值并且传的都是拷贝的话
//    }
//    }


//public class Test2 {  //我的实验
//
//    public static void change (int i){
//        i++;           //对象是传引用(call by reference)，简单类型是传值(call by value)
//                       //传值(call by value)不会改变实际参数的数值
//    }
//
//    public static void main (String args [ ] ) {
//    int a=5;
//    change(a);
//      System.out.println (a);  //5  
//    }
//    }

Test8

package com.whf.ByValue_ByReference;
/** 
 * @author :辰
 * E-mail: 15538323378@163.com 
 * 创建时间：2017-3-24 上午9:17:16 
 *  
 */
public class Test8 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a = 8;
        change(a);
        System.out.println(a);//8


        int x = 5;
        change1(x);
        System.out.println(x);//5
    }

    private static void change1(int x) {
        // TODO Auto-generated method stub
        x++;
    }

    private static void change(int a) {
        // TODO Auto-generated method stub
        a =10;
    }


}

参考地址：原文链接

辰小狼睡不醒
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Java的call by value和call by reference
08-26
在本篇文章里小编给大家总结了关于Java的call by value和call by reference的相关用法和知识点内容，需要的朋友们学习下。
call by value 和call by reference
weixin_30360497的博客
02-20 288
关于JAVA中参数传递问题有两种，一种是按值传递（如果是基本类型），另一种是按引用传递（如果是對象）. 首先以两个例子开始： 1）public class Test2 { public static void main (String [] args) {StringBuffer a = new StringBuffer ("A");StringBuffer b = new Str...
观察者模式
最新发布
qq_44585331的博客
05-24 21
设计模式---观察者模式
java call_详解Java的call by value和call by reference
weixin_33725576的博客
02-12 937
题目如下：Java传参的两种方式call by value(值传递)：传递的是值(针对基本数据类型)，如传递一个整型数值。实际上，按值传递在方法调用方法中，参数只是实际参数的一份拷贝。call by reference(引用传递)：传递的是对象的引用(针对对象)，即传递的是对象的地址。实际上，引用按传递时候会产生一份新的引用拷贝，新旧两份引用同时指向同一个地址。代码示例public class T...
Java call by value 和call by reference 的理解
写博客只为学习
04-16 304
Java中参数的传递有两种，一种是按值传递（传递的是具体的值，如基础数据类型），另一种是按引用传递（传递的是对象的引用，即对象的存储地址）。 [code="java"] main（） { //按值传递 int val = 20 ; print(val) ; //打印的是20 setVal(val); print(val) ; //打印的还是20 ...
java中参数传递详解:call by value（按值传递）和 call by reference（按引用传递）
F道人
12-04 3395
参数传递的一些知识，不全面部分望指点。 call by value： 按值传递 call by reference： 按引用传递 特点： call by value。 不改变值，即操作的是一个值的拷贝，所以原值不变。 call by reference 改变值，但是不改变实际参数的参考地址。可以理解为将另一个引用也指向同一个对象。 代码： publ
一文秒懂java到底是值传递还是引用传递
08-19
在程序设计语言中，按值调用（call by value）表示方法接收的是调用者提供的值，而按引用调用（call by reference）表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递...
Java参数传递及值传递实现原理详解
08-18
1. 按值传递（Call by Value） 按值传递是指将实参的值复制给形参，形参的变化不会影响实参的值。这种方式适用于基本数据类型，如int、long、float等。在按值传递中，实参的值被复制到形参中，形参的变化不会影响...
Java方法参数传递如何实现
08-19
在程序设计语言中，方法参数传递有两种方式：按值调用（call by value）和按引用调用（call by reference）。按值调用是指方法接收的是调用者提供的值，而按引用调用是指方法接收的是调用者提供的变量地址。Java采用...
Java基础思考之数据传递Java系列2021.pdf
04-27
在Java编程语言中，数据传递主要分为两种方式：按值传递（Pass by Value）和按引用传递（Pass by Reference）。这两种方式的理解对于深入理解Java对象和方法调用机制至关重要。 首先，我们要明确一点，Java中所有的...
by value 和by reference两种方法的使用tips（待补充）
weixin_30781631的博客
10-02 201
函数调用的一瞬间从实参(argument)到形参(parameter)发生一个值的或者是址的传递。 ----《通俗易懂C++》鲍钰 著 以上值的传递就是by value，址的传递就是by address、by reference，缺省情况下是by value，但是有时候也需要使用by address以及by reference； 例如： 1.解二元一次方程（待补充） 2.hash查找...
易混问题总结---（by value VS by reference)
Anonymous
08-12 993
传值与传址；在java中基本型别的传递是通过传值完成的，因此在下面的例子中虽然在Atest()中改变了传入的int i的值，但是并不会影响原来int i的值，简单点就是传入的int i的值的拷贝罢了而引用(reference)的传递呢？就有点不同了，在Atest()中的改变影响了原来的对象是内容，因为在java中reference的传递是by value的，也就是是说，是传递的reference的
Java参数传递机制：by value Or by reference?
爱追剧晓三鲜的博客
03-24 816
Java参数传递机制：by value Or by reference?一、前言二、by value三、by reference 一、前言 春招在即，相信很多小伙伴像我一样奔波于毕业与就业之间，但是学习不可少噢。今天抽点时间和大家聊聊 Java开发岗中，面试官常问或者笔试中常考的Java传参机制。 很多时候人们会因为[ Java 操控的是object reference（对象引用，虽然网上很多文章说是对象，这里不反驳）] 而臆测[ Java传参数也是以by reference (地址)方式进行传递]。因此，
call by value 和 call by reference
热门推荐
殇沫流年的专栏
05-27 2万+
6．下列正确的有（ ） 　　A． call by value       不会改变实际参数的数值 　　B． call by reference    能改变实际参数的参考地址 　　C． call by reference不能改变实际参数的参考地址 　　D． call by reference   能改变实际参数的内容 　　答案：ACD
实例浅析javascript call by value与call by reference
Boffi
08-13 763
基本类型是call by value的 var value = 1;  console.log(value); func(value); console.log(value); function func(val){   val = 3;   console.log(val); } 输出： 1 3 1 对象和数组call by referenc
String is passed by “reference” in Java[转]
messj的专栏
03-06 583
转自：http://www.programcreek.com/2013/09/string-is-passed-by-reference-in-java/ 先看String的不变性可以更好的理解文章内容，String的不变性网址为：http://www.programcreek.com/2009/02/diagram-to-show-java-strings-immutability/
java byreference_Java的几种对象引用（Reference）
weixin_39542889的博客
02-13 152
No.1 强引用 这个不用多说，就是最常见的对象引用。在GC时，只要不死无论如何都不会被回收，即使报OOM。No.2 弱引用(WeakReference) 只要发生GC就被回收，不管是否存活。同样用于内存敏感的程序。WeakHashMap类中使用，在ThreadLocal类中有通过弱引用处理垃圾回收问题。使用方式与下面软引用相同。No.3 软引用(SoftRefer...
字符串在Java中由“reference”传递
qq_1141193930的博客
12-27 159
字符串在Java中由“reference”传递   这是Java的经典问题。在stackoverflow上已经提出了许多类似的问题，并且有很多不正确/不完整的答案。如果你没有想太多，这个问题很简单。但如果你更多地考虑它，它可能会非常混乱。 1.一个有趣且令人困惑的代码片段 public static void main （String [ ] args ） { ...
请说明 Call by reference, Call by value的区别
05-24
在编程中，函数参数传递的方式可以分为 Call by reference 和 Call by value 两种方式。 Call by value 是指将实际参数的值复制给形式参数，函数内部对形式参数进行修改不会影响到实际参数的值。也就是说，这种方式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值