java什么是按值传递 Java按值传递

其实java什么是按值传递的问题并不复杂，但是又很多的朋友都不太了解Java按值传递，因此呢，今天小编就来为大家分享java什么是按值传递的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！

Java按值传递

在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：按引用传递的重要特点传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。示例如下：第1行 public class TempTest{第2行 private void test1(A a){第3行 a.age= 20;第4行 System.out.println("test1方法中的age="+a.age);第5行}第6行 public static void main(String[] args){第7行 TempTest t= new TempTest();第8行 A a= new A();第9行 a.age= 10;第10行 t.test1(a);第11行 System.out.println(”main方法中的age=”+a.age);第12行}第13行}第14行 class A{第15行 public int age= 0;第16行}运行结果如下： test1方法中的age=20 main方法中的age=20 4：理解按引用传递的过程??内存分配示意图要想正确理解按引用传递的过程，就必须学会理解内存分配的过程，内存分配示意图可以辅助我们去理解这个过程。用上面的例子来进行分析：（1）：运行开始，运行第8行，创建了一个A的实例，内存分配示意如下：（2）：运行第9行，是修改A实例里面的age的值，运行后内存分配示意如下：（3）：运行第10行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。内存分配示意如下：由于是按引用传递，也就是传递的是内存空间的地址，所以传递完成后形成的新的内存示意图如下：也就是说：是两个变量都指向同一个空间。（4）：运行第3行，为test1方法中的变量a指向的A实例的age进行赋值，完成后形成的新的内存示意图如下：此时A实例的age值的变化是由test1方法引起的（5）：运行第4行，根据此时的内存示意图，输出test1方法中的age=20（6）：运行第11行，根据此时的内存示意图，输出main方法中的age=20 5：对上述例子的改变理解了上面的例子，可能有人会问，那么能不能让按照引用传递的值，相互不影响呢？就是test1方法里面的修改不影响到main方法里面呢？方法是在test1方法里面新new一个实例就可以了。改变成下面的例子，其中第3行为新加的：第1行 public class TempTest{第2行 private void test1(A a){第3行 a= new A();//新加的一行第4行 a.age= 20;第5行 System.out.println("test1方法中的age="+a.age);第6行}第7行 public static void main(String[] args){第8行 TempTest t= new TempTest();第9行 A a= new A();第10行 a.age= 10;第11行 t.test1(a);第12行 System.out.println(”main方法中的age=”+a.age);第13行}第14行}第15行class A{第16行 public int age= 0;第17行}运行结果为： test1方法中的age=20 main方法中的age=10为什么这次的运行结果和前面的例子不一样呢，还是使用内存示意图来理解一下 6：再次理解按引用传递（1）：运行开始，运行第9行，创建了一个A的实例，内存分配示意如下：（2）：运行第10行，是修改A实例里面的age的值，运行后内存分配示意如下：（3）：运行第11行，是把main方法中的变量a所引用的内存空间地址，按引用传递给test1方法中的a变量。请注意：这两个a变量是完全不同的，不要被名称相同所蒙蔽。内存分配示意如下：由于是按引用传递，也就是传递的是内存空间的地址，所以传递完成后形成的新的内存示意图如下：也就是说：是两个变量都指向同一个空间。（4）：运行第3行，为test1方法中的变量a重新生成了新的A实例的，完成后形成的新的内存示意图如下：（5）：运行第4行，为test1方法中的变量a指向的新的A实例的age进行赋值，完成后形成的新的内存示意图如下：注意：这个时候test1方法中的变量a的age被改变，而main方法中的是没有改变的。（6）：运行第5行，根据此时的内存示意图，输出test1方法中的age=20（7）：运行第12行，根据此时的内存示意图，输出main方法中的age=10 7：

说明（1）：“在Java里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。

java中参数传递,按引用传递

Java提供两种不同的类型：引用类型和原始类型（或内置类型）。另外，Java还为每个原始类型提供了封装类(Wrapper)。如果需要一个整型变量，是使用基本的 int型呢，还是使用 Integer类的一个对象呢？如果需要声明一个布尔类型，是使用基本的 boolean，还是使用 Boolean类的一个对象呢？本文可帮助您作出决定。

下表列出了原始类型以及它们的对象封装类。

原始类型封装类

=================

boolean Boolean

char Character

byte Byte

short Short

int Integer

long Long

float Float

double Double

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。例如，假定一个方法中有两个局部变量，一个变量为 int原始类型，另一个变量是对一个 Integer对象的对象引用：

int i= 5;//原始类型

Integer j= new Integer(10);//对象引用

这两个变量都存储在局部变量表中，并且都是在 Java操作数堆栈中操作的，但对它们的表示却完全不同。（本文中以下部分将用通用术语堆栈代替操作数堆栈或局部变量表。）原始类型 int和对象引用各占堆栈的 32位。（要表示一个 int或一个对象引用，Java虚拟机实现至少需要使用 32位存储。）Integer对象的堆栈项并不是对象本身，而是一个对象引用。

Java中的所有对象都要通过对象引用访问。对象引用是指向对象存储所在堆中的某个区域的指针。当声明一个原始类型时，就为类型本身声明了存储。前面的两行代码表示如下：

引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

许多程序的代码将同时包含原始类型以及它们的对象封装。当检查它们是否相等时，同时使用这两种类型并了解它们如何正确相互作用和共存将成为问题。程序员必须了解这两种类型是如何工作和相互作用的，以避免代码出错。

例如，不能对原始类型调用方法，但可以对对象调用方法：

int j= 5;

j.hashCode();//错误

//...

Integer i= new Integer(5);

i.hashCode();//正确

使用原始类型无须调用 new，也无须创建对象。这节省了时间和空间。混合使用原始类型和对象也可能导致与赋值有关的意外结果。看起来没有错误的代码可能无法完成您希望做的工作。例如：

import java.awt.Point;

class Assign

{

public static void main(String args[])

{

int a= 1;

int b= 2;

Point x= new Point(0,0);

Point y= new Point(1,1);//1

System.out.println("a is"+ a);

System.out.println("b is"+ b);

System.out.println("x is"+ x);

System.out.println("y is"+ y);

System.out.println("Performing assignment and"+

"setLocation...");

a= b;

a++;

x= y;//2

x.setLocation(5,5);//3

System.out.println("a is"+a);

System.out.println("b is"+b);

System.out.println("x is"+x);

System.out.println("y is"+y);

}

}

这段代码生成以下输出：

a is 1

b is 2

x is java.awt.Point[x=0,y=0]

y is java.awt.Point[x=1,y=1]

Performing assignment and setLocation...

a is 3

b is 2

x is java.awt.Point[x=5,y=5]

y is java.awt.Point[x=5,y=5]

修改整数 a和 b的结果没什么意外的地方。b的值被赋予整型变量 a，结果 a的值增加了 1。这一输出反映了我们希望发生的情况。但是，令人感到意外的，是在赋值并调用 setLocation之后 x和 y对象的输出。我们在完成 x= y赋值之后特意对 x调用了 setLocation，x和 y的值怎么会相同呢？我们毕竟将 y赋予 x，然后更改了 x，这与我们对整数 a和 b进行的操作没什么不同。

这种混淆是由原始类型和对象的使用造成的。赋值对这两种类型所起的作用没什么不同。但它可能看起来所有不同。赋值使等号(=)左边的值等于右边的值。这一点对于原始类型（如前面的 int a和 b）是显而易见的。对于非原始类型（如 Point对象），赋值修改的是对象引用，而不是对象本身。因此，在语句

x= y;

之后，x等于 y。换句话说，因为 x和 y是对象引用，它们现在引用同一个对象。因此，对 x所作的任何更改也会更改 y。下面是//1处的代码执行以后的情况：

执行//2处的赋值以后情况如下：

当在//3处调用 setLocation时，这一方法是对 x引用的对象执行的。因为 x引用的 Point对象也正是 y所引用的对象，所以我们现在得到以下结果：

因为 x和 y引用同一个对象，所以对 x执行的所有方法与对 y执行的方法都作用于同一个对象。

区分引用类型和原始类型并理解引用的语义是很重要的。若做不到这一点，则会使编写的代码无法完成预定工作。

java中的值传递和引用传递到底有什么区别

java中在参数传递时有2种方式，两者的区别：

1、按值传递：值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。简单来说就是直接复制了一份数据过去，因为是直接复制，所以这种方式在传递时如果数据量非常大的话，运行效率自然就变低了，所以java在传递数据量很小的数据是值传递，比如java中的各种基本类型：int,float,double,boolean等类型的，具体可以自己测试。

结果：

2、按引用传递：引用传递其实就弥补了上面说的不足，如果每次传参数的时候都复制一份的话，如果这个参数占用的内存空间太大的话，运行效率会很底下，所以引用传递就是直接把内存地址传过去，也就是说引用传递时，操作的其实都是源数据，这样的话修改有时候会冲突，记得用逻辑弥补下就好了，具体的数据类型就比较多了，比如Object，二维数组，List，Map等除了基本类型的参数都是引用传递。代码：

有些文章中写的是java中所有的传参方式都是按值传递，这也说得通，无非就是文字游戏，因为无论是按值传递还是按引用传递都是把值传递过去了，所以就叫按值传递。

关于java什么是按值传递和Java按值传递的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。