精华内容
下载资源
问答
  • 我们平时看到的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 方法后被改变了,这种形为通常被描述为引用传递。

    按址传递

    按址传递是指是指在调用函数时将实际参数的地址直接传递到函数中(的形参),那么在函数中对参数所进行的修改,将影响到实际参数。
    就是形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作。但Java没有指针一说,所以可以直接理解为操作同一地址

    public class StringBase {
     
        public static void main(String[] args) {
            int[] m = new int[1,2,3]; 
     
            StringBase stringBase = new StringBase();
            stringBase.test5(n);
            System.out.println("m的值是:" + m);
        }
        
        public void test5(int [] n) {
            n[1] = 1;
        }
    }
    

    在数组的传递中,我们修改形参n中的值会发现m中的值也发生改变,那么是不是说Java其实是也存在按引用传递
    我们对这部分发生混淆是很正常的,这是因为我们对Java数据的存储方式没有一个很清楚的认知
    Java的数据类型分为基本数据类型和引用数据类型
    基本数据类型在存储时是讲变量名称和变量共同存放在栈中
    当我们数值传递时,创建的形参也在栈中,但即使它们的数值是一样的,也只是指向同一个数值地址,当形参发生改变时,则会新开辟一块数值地址存放新的数据,形参指向新的数据,所以实参不会受到影响
    在这里插入图片描述
    在这里插入图片描述
    对于引用数据类型 类 数组 接口来说 他们的名称放在栈中,数据放在堆中,形参和实参指向堆中同一位置,在改变形参的部分时 实参也跟着改变所以我们认为他们是按址传递
    但我们应该清楚的是引用数据类型在栈中的存储是下面这样的
    在这里插入图片描述
    这是在形参和实参之间的关系

    String类型是个例外,它是引用类型但它在修改形参时,不会影响实参,
    因为String是final类型

    总结

    Java程序设计语言对对象采用的不是引用调用,实际上,对象引用是按 值传递的。

    下面再总结一下Java中方法参数的使用情况:

    一个方法不能修改一个基本数据类型的参数(即数值型或布尔型)。
    一个方法可以改变一个对象参数的状态。
    一个方法不能让对象参数引用一个新的对象。

    展开全文
  • 在网上看到的一个帖子解释Java的按值传递和按引用传递,感觉挺全面,就转过来,以供以后学习参考:1:按值传递是什么指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:public class TempTest {private ...

    在网上看到的一个帖子解释Java的按值传递和按引用传递,感觉挺全面,就转过来,以供以后学习参考:

    1:按值传递是什么

    指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

    public class TempTest {

    private void test1(int a){

    //做点事情

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    int a = 3;

    t.test1(a);//这里传递的参数a就是按值传递

    }

    }

    按值传递重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。

    示例如下:

    public class TempTest {

    private void test1(int a){

    a = 5;

    System.out.println("test1方法中的a="+a);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    int a = 3;

    t.test1(a);//传递后,test1方法对变量值的改变不影响这里的a

    System.out.println(”main方法中的a=”+a);

    }

    }

    运行结果是:

    test1方法中的a=5

    main方法中的a=3

    2:按引用传递是什么

    指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。

    示例如下:

    public class TempTest {

    private void test1(A a){

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    t.test1(a); //这里传递的参数a就是按引用传递

    }

    }

    class A{

    public int age = 0;

    }

    3:按引用传递的重要特点

    传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

    示例如下:

    public class TempTest {

    private void test1(A a){

    a.age = 20;

    System.out.println("test1方法中的age="+a.age);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    a.age = 10;

    t.test1(a);

    System.out.println(”main方法中的age=”+a.age);

    }

    }

    class A{

    public int age = 0;

    }

    运行结果如下:

    test1方法中的age=20

    main方法中的age=20

    4:理解按引用传递的过程——内存分配示意图

    要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

    用上面的例子来进行分析:

    (1):运行开始,运行第13行,创建了一个A的实例,内存分配示意如下:

    54a0568a5d9606540e518e2b8cab94c8.png

    (2):运行第14行,是修改A实例里面的age的值,运行后内存分配示意如下:

    a715c6ec20dfa322a1b7c7fa10ccbe64.png

    (3):运行第15行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:

    1d7be5d20efce302a892de89f8b2fabe.png

    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    7a2eda57f0edefbaeb5f9df31fe9fe1b.png

    也就是说:是两个变量都指向同一个空间。

    (4):运行第5行,为test1方法中的变量a指向的A实例的age进行赋值,完成后形成的新的内存示意图如下:

    fdc8684a6d3391b85ca954f59df64e16.png

    此时A实例的age值的变化是由test1方法引起的

    (5):运行第6行,根据此时的内存示意图,输出test1方法中的age=20

    (6):运行第16行,根据此时的内存示意图,输出main方法中的age=20

    5:对上述例子的改变

    理解了上面的例子,可能有人会问,那么能不能让按照引用传递的值,相互不影响呢?就是test1方法里面的修改不影响到main方法里面呢?

    方法是在test1方法里面新new一个实例就可以了。改变成下面的例子,其中第3行为新加的:

    public class TempTest {

    private void test1(A a){

    a = new A();//新加的一行

    a.age = 20;

    System.out.println("test1方法中的age="+a.age);

    }

    public static void main(String[] args) {

    TempTest t = new TempTest();

    A a = new A();

    a.age = 10;

    t.test1(a);

    System.out.println(”main方法中的age=”+a.age);

    }

    }

    class A{

    public int age = 0;

    }

    运行结果为:

    test1方法中的age=20

    main方法中的age=10

    为什么这次的运行结果和前面的例子不一样呢,还是使用内存示意图来理解一下

    6:再次理解按引用传递

    (1):运行开始,运行第14行,创建了一个A的实例,内存分配示意如下:

    ceb3a77a2f344dba3bc44a060d57cf0b.png

    (2):运行第15行,是修改A实例里面的age的值,运行后内存分配示意如下:

    6c4c0604f69b0510cc345966115e4acb.png

    (3):运行第16行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:

    21d35b40deac615ef33a3ac3b5006f6f.png

    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    3788844b7146e37ad44bb464b728c182.png

    也就是说:是两个变量都指向同一个空间。

    (4):运行第5行,为test1方法中的变量a重新生成了新的A实例的,完成后形成的新的内存示意图如下:

    4e8936d48de35397adcd4619a61e6d2b.png

    (5):运行第6行,为test1方法中的变量a指向的新的A实例的age进行赋值,完成后形成的新的内存示意图如下:

    aa9eb5c0c01a6604d8f802d2224b146e.png

    注意:这个时候test1方法中的变量a的age被改变,而main方法中的是没有改变的。

    (6):运行第7行,根据此时的内存示意图,输出test1方法中的age=20

    (7):运行第17行,根据此时的内存示意图,输出main方法中的age=10

    7:说明

    (1):“在Java里面参数传递都是按值传递”这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递。

    (2):在Java里面只有基本类型和按照下面这种定义方式的String是按值传递,其它的都是按引用传递。就是直接使用双引号定义字符串方式:String str = “Java私塾”;

    原文链接:https://blog.csdn.net/zzp_403184692/article/details/8184751

    展开全文
  • 引言最近刷上的题目时碰到不少有关Java按值传递和按引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?Java按值传递...

    引言

    最近刷上的题目时碰到不少有关Java按值传递和按引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?

    Java按值传递和按引用传递

    首先问一句:Is Java “pass-by-reference” or “pass-by-value”? Java到底是按值传递还是按引用传递的呢?国外的网站上关于这个问题的讨论非常之多。官方答案:The Java Spec says that everything in Java is pass-by-value. There is no such thing as “pass-by-reference” in Java. 官方的说法是在java中只有按值传递,并没有所谓的按引用传递。

    基本数据类型的按值传递

    java数据类型可以分为两大类:基本类型(primitive types)和引用类型(reference types)。primitive types 包括boolean类型以及数值类型(numeric types)。numeric types又分为整型(integer types)和浮点型(floating-point type)。整型有5种:byte short int long char(char本质上是一种特殊的int)。浮点类型有float和double。关系整理一下如下图:

    7f3cd54f0e900fe0b387ef6912fa1139.png

    例1

    public class Swap {

    public static void main(String[] args) {

    int x = 10;

    int y = 20;

    swap(x, y);

    System.out.println("x(2) = " + x);

    System.out.println("y(2) = " + y);

    }

    public static void swap(int x, int y) {

    int temp = x;

    x = y;

    y = temp;

    System.out.println("x(1) = " + x);

    System.out.println("y(1) = " + y);

    }

    }

    /*输出

    x(1) = 20

    y(1) = 10

    x(2) = 10

    y(2) = 20

    */

    上面程序main函数调用swap函数来交换 x,y的值,然而调用函数之后发现main中x,y的值并未交换。包括在Java api中找不到一个可以交换两个变量的方法。这与Java语言的特性有关。通过一个图就可以知道上面程序的运行结果了。

    0d96afb080a49689fb578c475ea2f6b4.png

    由上图可知,main函数中的x,y和swap函数中的x,y分别存放在不同的区域,在main中调用swap函数的时候,会将main中的x,y的值赋给swap中的x,y。当swap函数中对x,y交换时只是对swap帧中的x,y做交换,并不会改变main中的x,y。所以当函数返回时main中的x,y并不会改变。swap执行过程图如下:

    9a6e2e6744fc9aee7791c55db0c81300.png

    对于基本数据类型 short int long float double char byte boolean这八种按值传递调用函数并不会改变在原函数中的值。

    引用数据类型的按值传递

    引用数据数据类型分为三种:①接口 ②类 ③数组对于引用数据类型的按值传递先给出一个实例对比实例进行分析。

    例2

    public static void main(String[] args) {

    int []a={10,20};

    System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=10,a[1]=20;

    swap(a, 0, 1);

    System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=20,a[1]=10;

    }

    public static void swap(int []a,int i,int j){

    int temp=a[i];

    a[i]=a[j];

    a[j]=temp;

    System.out.println("a[0] :"a[0]+"a[1] : "+a[1]);//a[0]=20,a[1]=10;

    }

    //输出

    /*a[0]=10 a[1]=20

    a[0]=20 a[1]=10

    a[0]=20 a[1]=10

    */

    运行程序后发现,swap函数对a[0] ,a[1]的操作竟然影响到了main函数中的a[0] ,a[1]的值,真是不可思议。为什么会产生如此之结果。原来引用类型的按值传递,传递的是对象的地址。还是用图来解释一下。

    89bb8c7560d0b51950c540324ba34e93.png

    由图可以看出在swap中仅仅是得到了数组的地址,并没有对数组的元素进行复制,在swap中对数组的操作是直接对main函数中数组的操作,因此swap函数返回后main函数中的a[0] ,a[1]的值发生交换。

    数组、类、接口按值传递的时候都是传递对象的地址。再来看一个比较复杂的实例。

    例3

    public class Main{

    public static void main(String[] args){

    Foo f = new Foo("f");

    changeReference(f); // It won't change the reference!

    modifyReference(f); // It will modify the object that the reference variable "f" refers to!

    }

    public static void changeReference(Foo a){

    Foo b = new Foo("b");

    a = b;

    }

    public static void modifyReference(Foo c){

    c.setAttribute("c");

    }

    }

    ①Foo f = new Foo(“f”);

    f40f7bdf134d698193af45b6f380b65c.png

    ②public static void changeReference(Foo a)

    90be628bc0927d6265462e7ae9717a1e.png

    ③changeReference(f);

    dd8972c8f37e56fcc066d9e9b6797de1.png

    ④Foo b = new Foo(“b”);

    06c6e53289f22f3425fb5d151d267e14.png

    ⑤a = b

    bc964efd2b3dc5aa5f75d01dc6333be7.png

    7ec041e4cf3486fe2b2b29d75aee3d52.png

    ⑥c.setAttribute(“c”);

    49f218f0649b8a1eac79be87658af36f.png

    经典笔试题目

    试题1

    public class Demo {

    public static void main(String[] args) {

    //demo1

    String str=new String("hello");

    char []chs={'w','o','r','l','d'};

    change(str, chs);

    System.out.println(str+" "+new String(chs));

    //-------------------------------------------------

    //demo2

    StringBuffer sb=new StringBuffer("hello");

    change(sb);

    System.out.println(sb);

    }

    public static void change(StringBuffer sb)

    {

    sb.append(" world");

    // sb.deleteCharAt(0);

    }

    public static void change(String str,char[]chs)

    {

    str.replace('h', 'H');

    chs[0]='W';

    }

    }

    上面程序段demo1和demo2分别输出什么,这里涉及到String特性,这道题目会做了,Java按值传递和按引用传递就彻底懂了,答案和解析先匿了。

    试题2

    public class foo {

    public static void main(String sgf[]) {

    StringBuffer a=new StringBuffer(“A”);

    StringBuffer b=new StringBuffer(“B”);

    operate(a,b);

    System.out.println(a+”.”+b);

    }

    static void operate(StringBuffer x,StringBuffer y) {

    x.append(y);

    y=x;

    }

    }

    参考文献

    1.https://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value

    展开全文
  • Java编程语言中最大的困惑之一是java是按值传递(Pass by Value)还是按引用传递(Pass by Reference)。在面试中经常提这个问题,但仍然看到应聘者对此感到困惑。首先,我们应该理解通过值传递和通过引用传递的含义。...

    Java编程语言中最大的困惑之一是java是按值传递(Pass by Value)还是按引用传递(Pass by Reference)。在面试中经常提这个问题,但仍然看到应聘者对此感到困惑。

    首先,我们应该理解通过值传递和通过引用传递的含义。

    传递值:将方法参数值复制到另一个变量,然后传递复制的对象,它称为按值传递。

    通过引用传递:将实际参数的别名或引用传递给方法,它称为按引用传递。

    Java总是按值传递而不是通过引用传递,我们可以用一个简单的例子来证明它。

    假设有一个类Balloon,如下所示。

    public class Balloon {

    private String color;

    public Balloon(){}

    public Balloon(String c){

    this.color=c;

    }

    public String getColor() {

    return color;

    }

    public void setColor(String color) {

    this.color = color;

    }

    }

    下面有一个简单的程序,使用通用方法交换两个对象,该类如下所示。

    public class Test {

    public static void main(String[] args) {

    Balloon red = new Balloon("Red"); //memory reference 50

    Balloon blue = new Balloon("Blue"); //memory reference 100

    swap(red, blue);

    System.out.println("red color="+red.getColor());

    System.out.println("blue color="+blue.getColor());

    foo(blue);

    System.out.println("blue color="+blue.getColor());

    }

    private static void foo(Balloon balloon) { //baloon=100

    balloon.setColor("Red"); //baloon=100

    balloon = new Balloon("Green"); //baloon=200

    balloon.setColor("Blue"); //baloon = 200

    }

    //Generic swap method

    public static void swap(Object o1, Object o2){

    Object temp = o1;

    o1=o2;

    o2=temp;

    }

    }

    当执行上面的程序时,得到以下输出。

    red color=Red

    blue color=Blue

    blue color=Red

    从输出的前两行中,可以很明显swap方法没有起什么作用。这是因为Java是按值传递的,这个swap()方法测试可以与任何编程语言一起使用,以检查它是通过值传递还是通过引用传递。

    让我们一步一步地分析程序的执行情况。

    Balloon red = new Balloon("Red");

    Balloon blue = new Balloon("Blue");

    当使用new运算符创建类的实例时,将创建实例,并且变量包含保存对象的内存的引用位置。假设“red”指向50并且“blue”指向100的内存位置,这些是两个Balloon对象的内存位置。

    现在,当调用swap()方法时,会创建两个新变量o1和o2,分别指向50和100。

    所以下面的代码片段解释了swap()方法执行中发生的事情。

    public static void swap(Object o1, Object o2){ //o1=50, o2=100

    Object temp = o1; //temp=50, o1=50, o2=100

    o1=o2; //temp=50, o1=100, o2=100

    o2=temp; //temp=50, o1=100, o2=50

    } //method terminated

    请注意,上面更改o1和o2的值,但它们是“Blue”和“Red”引用位置的副本,因此实际上“Blue”和“Red”的值没有变化,因此输出也没有变化。

    如果已经理解了这一点,可以很容易地理解混乱的原因。由于变量只是对象的引用,我们感到困惑的是传递了引用,因此java是通过引用传递的。但是传递了一个引用的副本,因此它通过了值。

    现在让我们分析一下foo()方法的执行情况。

    private static void foo(Balloon balloon) { //baloon=100

    balloon.setColor("Red"); //baloon=100

    balloon = new Balloon("Green"); //baloon=200

    balloon.setColor("Blue"); //baloon = 200

    }

    第一行是重要的一行,当我们调用一个方法时,在引用位置的Object上调用该方法。此时,balloon指向100,因此它的颜色变为Red。

    在下一行中,balloon的引用更改为200,并且执行的任何其他方法都发生在存储器位置200处的对象上,并且对存储器位置100处的对象没有任何影响。这解释了我们的程序输出的第三行打印:blue color=Red。

    变量是引用或指针,它的副本传递给方法,所以java总是按值传递。

    ¥ 我要打赏

    纠错/补充

    收藏

    加QQ群啦,易百教程官方技术学习群

    注意:建议每个人选自己的技术方向加群,同一个QQ最多限加 3 个群。

    展开全文
  • Java中的按值传递和按引用传递的代码详解发布于 2020-6-18|复制链接本文通过实例代码给大家介绍了Java中的按值传递和按引用传递的相关知识,感兴趣的朋友跟随脚本之家小妖一起学习吧先使用int实验:```javapublic ...
  • 本文通过实例代码给大家介绍了Java中的按值传递和按引用传递的相关知识,感兴趣的朋友跟随脚本之家小编一起学习吧
  • 深入理解--Java按值传递和按引用传递

    万次阅读 多人点赞 2017-07-20 15:48:49
    引言最近刷牛客网上的题目时碰到不少有关Java按值传递和按引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?Java...
  • Java的按值传递和按引用传递分析 Java的按值传递和按引用传递分析.pdf
  • Java中的按值传递和按引用传递的代码详解发布时间:2020-10-23 17:21:38来源:脚本之家阅读:93作者:围城灬先使用int实验:public class TTEST {private static List mList = new LinkedList();public static void ...
  • Java的按值传递和按引用传递分析.rar
  • 前天在做系统的时候被Java中参数传递问题卡了一下,回头查阅了相关的资料,对参数传递问题有了新的了解掌握,但是有个问题感觉还是很模糊,就是Java中到底是否只存在值传递,因为在查阅资料时,经常看到有人说Java...
  • 引言最近刷牛客网上的题目时碰到不少有关Java按值传递和按引用传递的问题,这种题目就是坑呀,在做错了n次之后,查找了多方资料进行总结既可以让自己在总结中得到提高,又可以让其他人少走弯路。何乐而不为?Java...
  • JS参数传递(值传递和引用传递)   以js为例解释按值传递和按引用传递 JavaScript的值传递和引用传递的区别  https://blog.csdn.net/lznsay/article/details/79234381    ...
  • 按值传递和按引用传递在java和以c++中很常见,Java对待对象是按引用传递和,对待基本数据类型是按值传递的。 这里一定要注意java的String,因为java的String虽然是一个类,但是如果直接写成String str0="abc"的话,...
  • java中的按值传递和按引用传递先使用int实验:[java] view plain copypublic class TTEST { private static List<UserEntity> mList = new LinkedList<UserEntity>(); ...
  • 0.0按值传递的是指在方法调用时,传递的参数是实参数值的副本.按引用传递指的是在方法调用时,传递的参数是实参的引用,也可以理解为实参所对应的内存空间的地址.为了理解java语言中的值传递与引用传递,首先给出下面的...
  • 我们通常提到的C#中的值和引用,大多数是类型和引用类型。所谓的类型是直接存储数据的,保存在内存中的;而引用类型是存储对的...那么,类型和引用类型在传递参数时又有什么不同呢?传值类型参数无需额外...
  • c++官方文档-按值传递和按引用传递 #include<stdio.h> #include<iostream> #include<queue> #include<map> #include<memory.h> #include <math.h> #...
  • Java按值传递, 值的变化指向问题 class Test { public static void main(String[] args) { String str = "娘家"; Test test = new Test(); test.changeVal(str); System.out.println("main方法: "+str); } ...
  • 其实Java里面没有按引用传递,全部都是按值传递的。 package test1; public class test1 { public static void main(String[] args) { Employee a=new Employee("Zelda"); Employee b=new Employee("Link"); ...
  • 值传递和引用传递详解:1:按值传递是什么指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:publicclassTempTest{privatevoidtest1(inta){//做点事情}publicstaticvoidmain(String[]args){TempTestt=...
  • C#值传递和引用传递

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,542
精华内容 1,016
关键字:

按值传递和按引用传递