精华内容
下载资源
问答
  • 2)当使用引用数据类型作为方法的形参时,若在方法体中 修改形参指向的数据内容,则会对实参变量的数值产生影响,因为形参变量和实参变量共享同一块堆区; 3)当使用引用数据类型作为方法的形参时,若在方法体中 ...

    结论:

    1)当使用基本数据类型作为方法的形参时,在方法体中对形参的修改不会影响到实参的数值
    2)当使用引用数据类型作为方法的形参时,若在方法体中 修改形参指向的数据内容,则会对实参变量的数值产生影响,因为形参变量和实参变量共享同一块堆区;
    3)当使用引用数据类型作为方法的形参时,若在方法体中 修改形参变量的指向,此时不会对实参变量的数值产生影响,因此形参变量和实参变量分别指向不同的堆区

    例一:基本数据类型作为形参,运行结果不改变实参

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            int n = 15; // n的值为15
            p.setAge(n); // 传入n的值
            System.out.println(p.getAge()); // 15
            n = 20; // n的值改为20
            System.out.println(p.getAge()); // 15
        }
    }
    
    class Person {
        private int age;
    
        public int getAge() {
            return this.age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    例二:引用类型–修改形参指向的数据内容,运行结果改变实参指向的数值,不改变实参地址

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            String[] fullname = new String[] { "Homer", "Simpson" };
            p.setName(fullname); // 传入fullname数组
            System.out.println(p.getName()); // "Homer Simpson"
            fullname[0] = "Bart"; // fullname数组的第一个元素修改为"Bart"
            System.out.println(p.getName()); // 是"Bart Simpson"
        }
    }
    
    class Person {
        private String[] name;
    
        public String getName() {
            return this.name[0] + " " + this.name[1];
        }
    
        public void setName(String[] name) {
            this.name = name;
        }
    }
    

    例三:引用类型–修改形参的指向,运行结果,不改变实参的任何东西

    public class Main {
        public static void main(String[] args) {
            Person p = new Person();
            String bob = "Bob";
            p.setName(bob); // 传入bob变量
            System.out.println(p.getName()); // "Bob"
            bob = "Alice"; // bob改名为Alice
            System.out.println(p.getName()); // "Bob"
        }
    }
    
    class Person {
        private String name;
    
        public String getName() {
            return this.name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
    展开全文
  • 浅析Java引用类型和方法参数传递,浅析Java引用类型和方法参数传递
  • 主要介绍了Java引用类型参数也是值传递,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java引用类型参数也是值传递

    千次阅读 2019-03-14 20:28:13
    Java引用类型作为参数传递给方法的时候,发生的仅仅是将引用类型变量的值复制一份给方法,让方法中的参数变量也指向内存中的对象区域。

    简述

    调用方法的时候,有需要传参数的情况。在Java中,参数的类型有基本类型和引用类型两种。

    一开始听到一个说法,Java没有引用传递,但是一直没有太多的思考在上面,直到前不久玩数组的时候,突然间发现把数组引用变量作为参数传递到一个方法当中进行操作之后,再去访问原数组,原数组元素的值竟然改变了。于是乎,就想到了之前在C++里面学过的引用传递,突然有一种错愕的感觉,就查了一些资料,探究当Java将引用类型变量作为参数传递给方法的时候,到底是值传递还是引用传递。

    结论:如果将Java引用类型变量作为参数传递给方法,是将引用变量的值传递给形参,而引用变量的值实际上就是引用对象在堆内存中的地址。也就是说,这个时候实参和形参指向了同一个对象,如果利用形参进行操作,操作的就是实参指向的对象,最后通过实参的那个引用访问,自然是被形参操作过的结果。


     基本类型参数

    基本类型参数是典型的值传递,著名的案例就是更换两个数的值。下面是这个问题的示例代码:

    public class Main {
    	public static void main(String[] args) {
    		int num1 = 11;
    		int num2 = 22;
    		System.out.println("Before the call: num1 is " + num1 + " and num2 is " + num2);
    		swap(num1, num2);
    		System.out.println("After the call: num1 is " + num1 + " and num2 is " + num2);
    	}
    	
    	public static void swap(int num1, int num2) {
    		System.out.println("num1 is " + num1 + " and num2 is " + num2 + " in method of swap.(before)");
    		int tmp = num1;
    		num1 = num2;
    		num2 = tmp;
    		System.out.println("num1 is " + num1 + " and num2 is " + num2 + " in method of swap.(after)");
    	}
    }
    

    运行结果如下:

    Before the call: num1 is 11 and num2 is 22
    num1 is 11 and num2 is 22 in method of swap.(before)
    num1 is 22 and num2 is 11 in method of swap.(after)
    After the call: num1 is 11 and num2 is 22

    通过运行结果,可以清楚地知道,通过这样的参数传递,交换的仅仅是形参的值,而main方法当中的两个数的值并没有发生变化。这就是值传递的结果。(具体如何通过方法交换基本类型的变量的值,可以参看笔者的另一篇博客:如何通过方法实现基本类型的数值交换。)

    引用类型参数

    通过一个数组引用演示引用类型参数的传递效果

    public class ArrayTest {
    	public static void main(String[] args) {
    		int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    		System.out.print("Before calling the inversion: ");
    		for (int i : arr) {
    			System.out.printf("%3d", i);
    		}
    		System.out.println();
    		inversion(arr);
    		System.out.print(" After calling the inversion: ");
    		for (int i : arr) {
    			System.out.printf("%3d", i);
    		}
    		System.out.println();
    		
    		setNull(arr);
    		System.out.println("@" + arr);
    	}
    	public static void inversion(int[] arr) {
    		int length = arr.length;
    		for (int i = 0; i <= length / 2; i++) {
    			int temp = arr[i];
    			arr[i] = arr[length - i - 1];
    			arr[length - i -1] = temp;
    		}
    	}
    	
    	public static void setNull(int[] array) {
    		System.out.println("#" + array);
    		array = null;
    		System.out.println("$" + array);
    	}
    }

    程序运行结果:

    Before calling the inversion:   0  1  2  3  4  5  6  7  8  9
       After calling the inversion:   9  8  7  6  4  5  3  2  1  0
    #[I@1d251891
    $null
    @[I@1d251891 

     程序中,在main方法中定义了一个数组,并且在类中定义了一个将数组元素倒置的方法inversion(),这个方法需要传入一个数组类型的引用。在main方法中调用这个方法,并将arr这个数组的引用作为参数传递给inversion方法,通过程序执行的结果,可以看到当inversion方法执行完毕,main方法中的arr数组的内容的确发生了倒置。

    那么,这个时候是否就可以认为,引用类型的传递是引用传递而并非值传递呢?按照资料显示的,引用类型的参数传递传递的是引用变量的值,有什么方法可以证明一下呢?setNull()方法提供了这样的证明。

    setNull方法的参数是数组的引用变量,程序中传入的是arr.进入方法,首先打印了array,然后将它置空再打印一次,然后在main方法中,打印arr的地址。程序运行的结果表示,array置空之前和arr指向的是同一区域,而后array=null却并没有影响到arr.

    所以,可以肯定,当一个引用类型的变量被作为参数传递到方法中的时候,仅仅是将变量值复制后传递过去,而本身没有发生改变去指向其他。

    当array=null的时候,array指向堆区的引用失效了。


    以上的示例和分析都表明,Java中的确没有引用传递,当把一个引用类型的变量作为参数传递给方法的时候,也仅仅是将引用变量的值复制一份给了方法中的参数,自己始终指向原本的对象。 

    展开全文
  • Java中的参数传递,到底是值传递还是引用传递? 错误理解一:值传递和引用传递,区分的条件是传递的内容,如果是个值,就是值传递。如果是个引用,就是引用传递。 错误理解二:Java引用传递。 错误理解三:传递的...

    文章内容为转载,转载自公众号Hollis关于我要彻底给你讲清楚,Java就是值传递,不接受争辩的那种!

    Java中的参数传递,到底是值传递还是引用传递?

    结论:Java只有值传递,没有引用传递!

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

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

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

    实参与形参

    我们都知道,在Java中定义方法的时候是可以定义参数的。比如ava中的main方法,public static void main(String[] args),这里面的args就是参数。参数在程序语言中分为形式参数和实际参数。

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

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

    简单举个例子:


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

    基本类型与引用类型

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


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

    赋值运算符“=”的作用

    num = 20;
    str = "java";
    

    对于基本类型 num,赋值运算符会直接改变变量的值,原来的值被覆盖掉。

    对于引用类型 str,赋值运算符会改变引用中所保存的地址,原来的地址被覆盖掉。但是原来的对象不会被改变(重要)。

    如上图所示,“hello” 字符串对象没有被改变。(没有被任何引用所指向的对象是垃圾,会被垃圾回收器GC回收

    值传递与引用传递

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

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

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

    • 值传递:将参数复制一份,修改形参不会对实参造成影响
    • 引用传递:将实参的地址传递给形参,修改形参也就是在修改实参

    我们来测试几段代码:

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

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

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

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

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

    print in pass , User{name='Tom', sex='man'}
    print in main , User{name='Tom', sex='man'}
    

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

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

    print in pass , Tom
    print in main , Mr.Q
    

    那么,问题来了。String是引用类型,new String("Mr.Q")在堆上创建了对象,name指向了Mr.Q的引用。那按照上面来说,应该是引用传递了,输出的结果应该pass和main是相同的,可是,为什么会不同呢?

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

    其实,是传递的地址值发生了改变

    String类型在值传递和引用传递问题中比较特殊,为什么说特殊呢,因为对于一些常量字符串的创建,只要判断对象在堆中不存在,便会创建一个新的,如果是创建新对象,那么引用地址都会变。我们可以通过一个简单的例子来解释下:

    a是:hello --- b是:你好
    

    String a = “hello”; 在 String 池中检查并创建一个常量:“hello”,给 a 分配一个栈内存,在此存储常量 hello 的地址。

    String b= a; 给 b 分配一个栈内存,在此存储常量 hello 的地址。相当于 a 把自己持有的地址,复制给了 b。

    b = “你好”; 在 String 池中检查是否有 “你好” 的常量。

    • 如果有,将 b 的地址指向 “你好” 的地址。
    • 如果 String 池中没有 “你好” 常量,在堆内存中创建 “你好” 常量,并将 b 地址指向 “你好”。


    我们再来看一个反例,来验证 “Java中参数传递 没有引用传递”

    public class Test {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Student s1 = new Student("小张");
            Student s2 = new Student("小李");
            Test.swap(s1, s2);
            System.out.println("s1:" + s1.getName());
            System.out.println("s2:" + s2.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());
        }
    }
    

    结果:

    x:小李
    y:小张
    s1:小张
    s2:小李

    方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝。


    Java中的值传递

    值传递和引用传递之前的区别到底是什么?

    两者的最主要区别就是是直接传递的,还是传递的是一个副本

    这里我们来举一个形象的例子。再来深入理解一下传值调用和传引用调用:


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

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

    那我们再说回到这段代码中:

    print in pass , User{name='Tom', sex='man'}
    print in main , User{name='Tom', sex='man'}
    

    看看在调用中,到底发生了什么?

    在参数传递的过程中,实际参数的地址0x666拷贝给了形参。这个过程其实就是值传递(这个值,理解为引用的地址),只不过传递的值得内容是对象的应用。

    那为什么我们改了user中的属性的值,却对原来的user产生了影响呢?

    其实,这个过程就好像是:你复制了一把你家里的钥匙给到你的朋友,他拿到钥匙以后,并没有在这把钥匙上做任何改动,而是通过钥匙打开了你家里的房门,进到屋里,把你家的电视给砸了。

    这个过程,对你手里的钥匙来说,是没有影响的,但是你的钥匙对应的房子里面的内容却是被人改动了。

    也就是说,Java对象的传递,是通过复制的方式把引用关系传递了,如果我们没有改引用关系,而是找到引用的地址,把里面的内容改了,是会对调用方有影响的,因为大家指向的是同一个共享对象。

    那么,如果我们改动一下pass方法的内容:

    上面的代码中,我们在pass方法中,重新new了一个user对象,并改变了他的值,输出结果如下:

    print in pass , User{name='Tom'}
    print in main , User{name='Mr.Q'}
    

    也就是说,我把我的钥匙复制给了我的朋友,但是我立马换了我家的锁。因为一new就会在堆上开辟新空间,地址就发生了改变,此时的user不再指向0x666了,理解为我换锁了,朋友当然进不了我家,砸不了电视了。所以此时在pass方法中修改name,不会对我家造成任何影响。

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

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


    所以,值传递和引用传递的区别并不是传递的内容,而是实参到底有没有被复制一份给形参

    在判断实参内容有没有受影响的时候,要看传的的是什么,如果你传递的是个地址,那么就看这个地址的变化会不会有影响,而不是看地址指向的对象的变化。

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


    总结

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

    按共享传递,是指在调用函数时,传递给函数的是实参的地址的拷贝(如果实参在栈中,则直接拷贝该值)。

    在函数内部对参数进行操作时,需要先拷贝的地址寻找到具体的值,再进行操作。

    如果该值在栈中,那么因为是直接拷贝的值,所以函数内部对参数进行操作不会对外部变量产生影响。

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

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

    • 传递的值在栈中,直接拷贝一份值传递,改变的形参不会对实参造成影响
    • 传递的值在栈中存放的是地址(引用),先根据栈中的地址找到在堆上的值,然后把地址拷贝一份(拷贝的地址是一个值),此时形参和实参指向堆上同一个地址,形参的修改导致了实参的改变。

    Java中的参数传递,是值传递!

    Java只有值传递!

    Java只有值传递!

    Java只有值传递!

    展开全文
  • java参数传递(值类型,引用类型

    千次阅读 2019-03-05 18:04:39
    基本类型作为参数传递时,是传递值的拷贝, 无论你怎么改变这个拷贝 , 原值是不会改变的 ,输出的结果证明了这一点: Before change, n = 3 After changeData(n), n = 3 3、总结: java只有值传递 ,题目中...

    未整理:
    这一次,让你彻底明白Java的值传递和引用传递!


    1、参数:引用类型

    以下代码执行后,结果是:AB,B。

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

    解释:

    StringBuffer a = newStringBuffer("A"); 
    StringBuffer b = newStringBuffer("B"); 
    

    此时内存中的状态如下图所示:
    在这里插入图片描述 进入如下方法后,内存中的状态为:

    public static void operator(StringBuffer x, StringBuffer y) { 
        x.append(y); y = x; 
    }
    

    在这里插入图片描述下面语句执行后,内存的状态为:

      x.append(y);
    

    在这里插入图片描述
    下面语句执行后,内存的状态为:

    y = x; 
    

    在这里插入图片描述当operator方法执行完毕后内存中的状态为:因为方法执行完毕,局部变量消除:
    在这里插入图片描述

    2、参数:基本类型

    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) {
    
            n = 10;
    
        }
    
    }
    

    基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝原值是不会改变的,输出的结果证明了这一点:

    Before change, n = 3
    After changeData(n), n = 3
    

    3、总结:

    java只有值传递,题目中相当于把a,b复制了一份传递到x,y中(复制的是a,b的内存地址),所以a与X,b与Y指向同一片内存地址,所以操作X指向的内容也会改变a指向的内容。

    Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。

    • 如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的 值不会改变原始的值
    • 如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址
      • 如果在函数中没有改变这个副本的地址,而是改变了地址中的 值,那么在函数内的改变会影响到传入的参数
      • 如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的 地址,所以不会改变参数的值
    展开全文
  • 参数传递主要分为两种:一种是参数是基本类型,一种是参数为引用类型。 基本数据类型 这个相信大家都没什么问题,基本类型作为参数传递的时候是在一个方法栈中开辟了一块新内存,拷贝了原来的数据值,所以无论我们...
  • java基本数据类型传递引用传递区别详解

    万次阅读 多人点赞 2016-04-19 17:12:57
    java的值传递和引用传递在面试中一般都会都被涉及到,今天我们就来聊聊这个问题,首先我们必须认识到这个问题一般是相对函数而言的,也就是java中的方法参数,那么我们先来回顾一下在程序设计语言中有关参数传递给...
  • JAVA参数传递方式 (按值传递与引用传递区别)

    千次阅读 多人点赞 2018-09-30 22:58:30
    首先要明确的是JAVA中没有引用传递, 全部是按值调用 令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用...
  • Java引用数据类型作为参数传递时,如果参数地址值发生改变,那么将只是形参改变,实参并没有变化
  • 经典名言:O’Reilly’s Java in a Nutshell by David Flanagan (see Resources) puts it best: “Java manipulates objects ‘by reference,’ but it passes object references to methods ‘by val
  • JAVA传递还是引用传递不管你传的是什么,传过去的都只是一个副本而已,这个副本作为方法的局部变量保存在栈中。如果传的是基本数据类型,修改这个值并不会影响作为参数传进来的那个变量,因为你修改的是方法的局部...
  • Java参数传递分析

    千次阅读 2021-02-28 06:08:03
    Java之中的参数传递,只有按值传递!...Java参数传递是值传递还是引用传递?当一个对象被当作参数传递到一个方法后,在此方法内可以改变这个对象的属性,那么这里到底是值传递还是引用传递?答:是值传递。Ja...
  • java中的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中数据类型分为两大类:基本类型和引用类型。相应的,变量也分这两种类型:基本类型和引用类型。 基本类型的变量保存原始值,即它代表的值就是数值本身; 而引用类型的变量保存的值是引用值,...
  • java中数据类型分两种:基本数据类型引用数据类型 基本数据类型有:整型类型的数据(byte、short 、int 、long )浮点型、字符型、布尔型 byte:Java中最小的数据类型,在内存中占8位(bit),即1个字节,取值...
  • Java 是值传递还是引用传递

    万次阅读 多人点赞 2019-03-20 02:40:16
    最近整理面试题,整理到值传递引用传递,到网上搜了一圈,争议很大。带着一脸蒙圈,线上线下查了好多资料。最终有所收获,所以分享给大家,希望能对你有所帮助。 首先说下我的感受,这个题目出的很好,但是在 ...
  • 前言 在Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用,这是一个饱受争议的话题。若传的是值,那么函数接收的只是实参的一个副本,函数对形参的操作并不会对实参产生影响;若传的是引用,...
  • java中的方法可以传递参数参数传递方法就是值传递参数有形参和实参,定义方法时写的参数叫形参,真正调用方法时,传递参数叫实参。 调用方法时,会把实参传递给形参,方法内部其实是在使用形参。 所谓值...
  • 基本数据类型 整型:byte,short,int,long浮点型:float,double字符型:char布尔型:boolean引用数据类型 数组对象(类、接口)一般情况下,基本数据类型传递时是值传递引用数据类型引用传递。而String有些不...
  • java泛型方法参数传递

    千次阅读 2021-01-27 01:38:10
    Java参数,不管是原始类型还是引用类型传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始...
  • Java笔记】引用类型参数传值

    千次阅读 2017-09-17 15:34:06
    接口当参数引用类型时,“传值”传递的是变量中存放的“引用”,而不是变量所引用的实体。例:Circle.javapublic class Circle { double radius; Circle(double r) //构造函数 { radius=r; } double ...
  • Java中,当对象作为参数传递时,究竟传递的是对象的值,还是对象的引用? 先说结论,无论你传的是基本数据类型还是引用类型,都是值传递。(因为引用类型只不过是把指向对象的地址拷贝一份传递给形参)。 这样理解...
  • java的值传递引用传递

    千次阅读 2021-02-26 08:26:02
    昨天博主在对于值传递引用传递这里栽了一个大坑啊,导致一下午时间都浪费在这里,我们先说下值传递引用传递java官方解释:值传递:(形式参数...引用传递:(形式参数类型是引用数据类型参数):也称为传地址。方法...
  • Java中没有指针,没有引用传递了,仅仅有值传递。但是可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements 接口实现多继承的功能。 值传递:方法调用时,实际参数把它的值传递给对应的...
  • 探究Java方法的参数传递是值传递还是引用传递
  • ----------- android培训、java培训、java学习型技术博客、期待与您交流!...//基本数据类型参数传递   /* class Object_parameter{ public static void main(String args[]){ int x=3;
  • Java中的参数传递

    万次阅读 多人点赞 2018-01-19 13:52:15
    引用参数指的还是原来的那个引用,但是Java里面参数类型是对象时是复制了原来的引用到一块新的内存,两者之间没有关系 1:按值传递是什么 指的是在方法调用时,传递参数是按值的拷贝传递。示例如下: ...
  • 原理知识: 如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟...如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 264,378
精华内容 105,751
关键字:

java引用类型参数传递

java 订阅