07Java的传值特性

Java——值传递和引⽤传递值传递在⽅法被调⽤时，实参通过形参把它的内容副本传⼊⽅法内部，此时形参接收到的内容是实参值的⼀个拷贝，因此在⽅法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容。

先来看个例⼦：public static void valueCross(int age,float weight) {System.out.println("传⼊的age值："+age);System.out.println("传⼊的weight值："+weight);age=23;weight=60;System.out.println("修改后的age值："+age);System.out.println("修改后的weight值："+weight);}public static void main(String[] args) {int age=10;int weight=50;valueCross(age,weight);System.out.println("⽅法执⾏后的age："+age);System.out.println("⽅法执⾏后的weight："+weight);}运⾏结果：传⼊的age值：10传⼊的weight值：50.0修改后的age值：23修改后的weight值：60.0⽅法执⾏后的age：10⽅法执⾏后的weight：50我们可以看到valueCross⽅法执⾏后，实参age和weight的值并没有发⽣变化，这是什么原因？⾸先程序运⾏时，先从main⽅法开始执⾏，此时JVM为main()⽅法往虚拟机栈中压⼊⼀个栈帧，即为当前栈帧，⽤来存放main()中的局部变量表(包括参数)、操作栈、⽅法出⼝等信息，如a和w都是mian()⽅法中的局部变量，因此可以断定，age和weight是躺着mian⽅法所在的栈帧中接着调⽤valueCross⽅法，此时JVM为valueCross()⽅法往虚拟机中压⼊⼀个栈帧，即为当前栈帧，⽤于存放valueCross⽅法的局部变量等信息；因此age和weight是躺着valueCrossTest⽅法所在的栈帧中，⽽他们的值是从a和w的值copy了⼀份副本⽽得，如图：因此这两个age和weight对应的内容不是同⼀个，在valueCross⽅法中修改的只是⾃⼰栈中的内容，并没有修改main⽅法栈中的内容引⽤传递”引⽤”也就是指向真实内容的地址值，在⽅法调⽤时，实参的地址通过⽅法调⽤被传递给相应的形参，在⽅法体内，形参和实参指向同⼀块内存地址，对形参的操作会影响的真实内容。

Java中的参数传递
实参与形参
1. 形式参数：是在定义函数名和函数体的时候使⽤的参数,⽬的是⽤来接收调⽤该函数时传⼊的参数。

2. 实际参数：在调⽤有参函数时，主调函数和被调函数之间有数据传递关系。

在主调函数中调⽤⼀个函数时，函数名后⾯括号中的参数
称为“实际参数”。

3. 实际参数是调⽤有参⽅法的时候真正传递的内容，⽽形式参数是⽤于接收实参内容的参数。

值传递和引⽤传递
1. 值传递（pass by value）：是指在调⽤函数时将实际参数复制⼀份传递到函数中，这样在函数中如果对参数进⾏修改，将不会影响到实
际参数。

2. 引⽤传递（pass by reference）：是指在调⽤函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进⾏的修改，将影响
到实际参数。

传共享对象调⽤（共享对象传递）
传共享对象调⽤中，先获取到实际参数的地址，然后将其复制，并把该地址的拷贝传递给被调函数的形式参数。

因为参数的地址都指向同⼀个对象，所以我们也称之为"传共享对象"，所以，如果在被调函数中改变了形式参数的值，调⽤者是可以看到这种变化的。

Java中参数传递
1. 基本数据类型使⽤值传递
2. 对象传递，把对象的引⽤当做值传递给⽅法，即共享对象传递
3. Java对象的传递，是通过复制的⽅式把引⽤关系传递了，如果我们没有改引⽤关系，⽽是找到引⽤的地址，把⾥⾯的内容改了，是会
对调⽤⽅有影响的，因为⼤家指向的是同⼀个共享对象。

4. Java的对象传递，如果是修改引⽤，是不会对原来的对象有任何影响的，但是如果直接修改共享对象的属性的值，是会对原来的对象
有影响的。

Java中传值与传引⽤不管Java参数类型是什么，⼀律传递参数的副本。

《Thinking In Java》：“When you're passing primitives into a method,you get a distinct copy of the primitive.When you're passing a reference into a method,you get a copy of the reference.（如果Java是传值，那么传递的是值的副本；如果Java是传引⽤，那么传递的是引⽤的副本）”。

在Java中，变量分为以下两类。

1. 对于基本类型变量（int, long, double, float, byte, boolean, char），Java是传值的副本。

2. 对于⼀切对象型变量，Java都是传引⽤的副本。

（如String） 对基本类型⽽⾔，传值就是把⾃⼰复制⼀份传递，即使⾃⼰的副本变了，⾃⼰也不变。

⽽对于对象类型⽽⾔，它传的引⽤副本指向⾃⼰的地址，⽽不是⾃⼰实际值的副本。

《Thinking In Java》：“不管是基本类型还是对象类型，都是传值。

”，这种说法也没有错，因为它们把引⽤副本也当做是⼀种“值”。

举⼏个栗⼦例⼀：基本数据类型 可以看出，test()⽅法并没有对test参数源产⽣影响，即对main⽅法中的test变量没有影响，说明参数类型是简单类型的时候，是按值传递的。

以参数形式传递简单类型的变量时，实际上是将参数的值作为⼀个副本传进⽅法函数的，所以在⽅法函数中不管怎么改变其值，其结果都是只改变了副本的值，⽽不是源值。

例⼆：对象类型⼀ 其中string是⼀个引⽤，Java对引⽤形式传递对象类型的变量时，实际上是将引⽤作为⼀个副本传进⽅法函数的。

⽽这个引⽤的副本所指向的就是对象的地址。

所以说，通过引⽤副本找到地址并修改地址中的值，也就修改了对象。

值传递在Java中在程序设计中，值传递（Pass by Value）和引用传递（Pass by Reference）是两种不同的参数传递方式。

在Java中，作为一种面向对象的编程语言，值传递在很多场景中起到了重要的作用。

本文将探讨值传递在Java中的概念、使用方式和一些注意事项。

一、概念值传递是指在方法调用时，将实际参数的值复制给形式参数，实际参数的改变不会影响到形式参数的值。

Java中的基本类型(int、float、boolean等)都是以值传递的方式进行参数传递。

二、基本类型的值传递1. 基本类型的值传递基本类型在值传递过程中，会将实际参数的值复制一份给形式参数，即在方法内部操作的是参数的副本，不会改变原始值。

```javapublic class ValuePassingExample {public static void main(String[] args) {int num1 = 10;System.out.println("Before method call, num1 = " + num1);changeValue(num1);}public static void changeValue(int num) {num = 20;}}```输出结果：```Before method call, num1 = 10After method call, num1 = 10```2. 基本类型数组的值传递基本类型数组作为参数传递时，同样是值传递的方式。

在方法内部操作数组的元素值时，不会改变原始数组的值。

```javapublic class ArrayPassingExample {public static void main(String[] args) {int[] numbers = {1, 2, 3, 4, 5};numbers[0]);changeArrayValue(numbers);System.out.println("After method call, numbers[0] = " + numbers[0]);}public static void changeArrayValue(int[] arr) {arr[0] = 10;}}```输出结果：```Before method call, numbers[0] = 1After method call, numbers[0] = 10```三、对象类型的值传递1. 对象类型的值传递在Java中，对象类型包括类、接口和数组。

Java值传递以及引用的传递、数组的传递！！许多编程语言都有2种方法将参数传递给方法------按值传递和按引用传递。

与其他语言不同，Java不允许程序员选择按值传递还是按引用传递各个参数，基本类型(byte--short--int--long--float--double--boolean--char)的变量总是按值传递。

就对象而言，不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的-----------也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。

现在说说数组：如果将单个基本类型数组的元素传递给方法，并在方法中对其进行修改，则在被调用方法结束执行时，该元素中存储的并不是修改后的值，因为这种元素是按值传递，如果传递的是数组的引用，则对数组元素的后续修改可以在原始数组中反映出来（因为数组本身就是个对象，int[] a = new int[2];，这里面的int是数组元素的类型，而数组元素的修改是操作对象）。

对于单个非基本类型数组的元素在方法中修改，则在被调用方法结束执行时，该元素中存储的是修改后的值，因为这种元素是按引用传递的，对象的改动将在源数组的数组元素中反映出来。

下面看个小程序：1. public class Test{2.3. String str = new String("good");4. char[] ch = {'a','b','c'};5. int i = 10;6. public void change(String str,char[] ch,int i){7.8. str = "test ok";9. ch[0] = 'g';10. i++;11. }12.13. public static void main(String[] args){14.15. Test tt = new Test();16. tt.change(tt.str,tt.ch,tt.i);17. System.out.println(tt.i);18. System.out.print(tt.str+" and ");19. System.out.println(tt.ch);20. }21. }str是String类型的引用，i是基本类型变量，ch是数组名，也是数组对象的引用在chang()方法里，str="test ok"，是一个新的对象把首地址放在引用变量str上；而ch[0]='g';因为传的是数组的引用，而此时ch[0]='g';是对数组元素的操作，能修改源数组的内容；i是整型值，只是把值copy了一份给方法，在方法的变化是不改变的源i的。

java 传递方法参数传递方法参数是Java编程中一项常见的操作，它在方法调用过程中起到了重要的作用。

通过传递方法参数，我们可以向方法中传递数据或者对象，使得方法能够接收并处理这些数据，从而实现特定的功能。

在Java中，传递方法参数有两种方式：值传递和引用传递。

值传递是指将实际参数的值复制一份传递给方法，在方法内部对参数的修改不会影响到实际参数的值。

而引用传递则是指将实际参数的地址传递给方法，方法内部对参数的修改会影响到实际参数的值。

在使用值传递时，我们可以将基本类型的数据作为参数传递给方法。

例如，我们可以将一个整数、一个浮点数或者一个布尔值作为参数传递给方法，并在方法内部对其进行处理。

值传递的特点是方法内部对参数的修改不会影响到方法外部的变量。

另一种方式是引用传递，它适用于传递对象作为参数的情况。

在Java中，对象是通过引用来传递的，传递的是对象的地址。

当我们将一个对象作为参数传递给方法时，方法内部可以通过引用修改对象的属性或者调用对象的方法。

这种传递方式能够使方法具有更大的灵活性，可以对对象进行更复杂的操作。

在实际编程中，我们通常会使用值传递和引用传递的组合来完成复杂的任务。

通过值传递，我们可以传递基本类型的数据，并在方法内部对其进行处理；通过引用传递，我们可以传递对象，并在方法内部对对象进行操作。

除了传递参数的方式，我们还可以在方法定义时指定参数的类型和个数。

在Java中，方法的参数可以是基本类型或者对象类型，并且可以有多个参数。

通过指定参数的类型和个数，我们可以更准确地传递参数，并确保方法的正确执行。

传递方法参数的方式和方法的定义有着密切的关系。

在调用方法时，我们需要根据方法的定义来传递参数，并确保参数的类型和个数与方法的定义相匹配。

如果参数的类型和个数不匹配，编译器将会报错，提示我们进行修改。

在实际编程中，我们经常会使用方法来完成特定的任务，尤其是在面向对象的程序设计中。

通过传递方法参数，我们可以将数据或者对象传递给方法，并在方法内部对其进行操作。

Java：详解传值和传引⽤传值和传引⽤When you’re passing primitives into a method ,you get a distinct copy of the primitive. When you’re passing a reference into amethod , you get a copy of the reference.以上引⾃《Thinging in Java》，总结⼀下就是不管Java参数的类型是什么，⼀律传递参数的副本。

在Java中，变量分为以下两类：1. 对于基本类型变量（int、long、double、float、byte、boolean、char），Java是传值的副本。

2. 对于⼀切对象型变量，Java都是传引⽤的副本，其实穿引⽤副本的实质就是复制指向地址的指针。

⼀、传值例1：传Int类型的值程序{% highlight java linenos %}@Testpublic void passInt(){int testInt = 0;System.out.println(“Before operation, testInt is : ” + testInt);intOperation(testInt);System.out.println(“After operation, testInt is : ” + testInt);}public void intOperation(int i){i = 5;System.out.println("In operation, testInt is : " + i);}{% endhighlight %}结果{% highlight java linenos %}Before operation, testInt is : 0In operation, testInt is : 5After operation, testInt is : 0{% endhighlight %}总结结果不难看出来，虽说intOperation()⽅法改变了传进来的参数值，但对这个参数源本⾝并没有影响，参数类型是简单类型的时候，是按值传递的。

Java中没有指针，所以也没有引用传递了，仅仅有值传递不过可以通过对象的方式来实现引用传递类似java没有多继承但可以用多次implements 接口实现多继承的功能值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。

引用传递：也称为传地址。

方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

Java参数按值传递面试题:当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?答:是值传递。

Java 编程语言只有值传递参数。

当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。

指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。

-------------------------------------------------------------在Java 应用程序中永远不会传递对象，而只传递对象引用。

因此是按引用传递对象。

但重要的是要区分参数是如何传递的，这才是该节选的意图。

Java 应用程序按引用传递对象这一事实并不意味着Java 应用程序按引用传递参数。

参数可以是对象引用，而Java 应用程序是按值传递对象引用的。

Java 应用程序中的变量可以为以下两种类型之一：引用类型或基本类型。

当作为参数传递给一个方法时，处理这两种类型的方式是相同的。

两种类型都是按值传递的；没有一种按引用传递。

按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。

因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。

按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。

java中的传值与传引⽤java函数中的传值和传引⽤问题⼀直是个⽐较“邪门”的问题，其实java函数中的参数都是传递值的，所不同的是对于基本数据类型传递的是参数的⼀份拷贝，对于类类型传递的是该类参数的引⽤的拷贝，当在函数体中修改参数值时，⽆论是基本类型的参数还是引⽤类型的参数，修改的只是该参数的拷贝，不影响函数实参的值，如果修改的是引⽤类型的成员值，则该实参引⽤的成员值是可以改变的。

package com.test9.echo;/**** @author Echo* @date 2018/1/27**/public class Test {public static void changeInt(int i) {// 改变int型变量的函数i = 100;}public static void changeString(String s) {// 改变String型变量的函数s = "changeString";}public static void changeModel(Model model) {// 改变Model型变量的函数model = new Model();model.i = 1;model.s = "changeModel";}public static void changeModel2(Model model) {// 改变Model型变量的成员的函数model.i = 1;model.s = "changeModel";}// 测试程序public static void main(String[] args) {int i = 0;String s = "hello";Model model = new Model();Model model2 = new Model();changeInt(i);System.out.println("i=" + i);changeString(s);System.out.println("s=" + s);changeModel(model);System.out.println("model:" + model.s + " " + model.i);changeModel2(model2);System.out.println("model2:" + model2.s + " " + model2.i);}}// 类Modelclass Model {public int i = 0;public String s = "no value";}。