JAVA的值传递问题

为什么 Java 中只有值传递?

首先回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。按值调用(call by value)表示方法接收的是调用者提供的值,而按引用调用(call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。 它用来描述各种程序设计语言(不只是Java)中方法参数传递方式。

Java程序设计语言总是采用按值调用。也就是说,方法得到的是所有参数值的一个拷贝,也就是说,方法不能修改传递给它的任何参数变量的内容。

下面通过 3 个例子来给大家说明

example 1

public static void main(String[] args) {
    int num1 = 10; int num2 = 20; swap(num1, num2); System.out.println("num1 = " + num1); System.out.println("num2 = " + num2); } public static void swap(int a, int b) { int temp = a; a = b; b = temp; System.out.println("a = " + a); System.out.println("b = " + b); }

结果:

a = 20
b = 10
num1 = 10
num2 = 20

解析:

example 1

在swap方法中,a、b的值进行交换,并不会影响到 num1、num2。因为,a、b中的值,只是从 num1、num2 的复制过来的。也就是说,a、b相当于num1、num2 的副本,副本的内容无论怎么修改,都不会影响到原件本身。

通过上面例子,我们已经知道了一个方法不能修改一个基本数据类型的参数,而对象引用作为参数就不一样,请看 example2.

example 2

	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 }; System.out.println(arr[0]); change(arr); System.out.println(arr[0]); } public static void change(int[] array) { // 将数组的第一个元素变为0 array[0] = 0; }

结果:

1
0

解析:

example 2

array 被初始化 arr 的拷贝也就是一个对象的引用,也就是说 array 和 arr 指向的时同一个数组对象。 因此,外部对引用对象的改变会反映到所对应的对象上。

通过 example2 我们已经看到,实现一个改变对象参数状态的方法并不是一件难事。理由很简单,方法得到的是对象引用的拷贝,对象引用及其他的拷贝同时引用同一个对象。

很多程序设计语言(特别是,C++和Pascal)提供了两种参数传递的方式:值调用和引用调用。有些程序员(甚至本书的作者)认为Java程序设计语言对对象采用的是引用调用,实际上,这种理解是不对的。由于这种误解具有一定的普遍性,所以下面给出一个反例来详细地阐述一下这个问题。

example 3

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程序设计语言对对象采用的不是引用调用,实际上,对象引用是按 值传递的。

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

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

转载于:https://www.cnblogs.com/yangjinprocess/p/10112280.html

<think>首先,用户的问题是“java值传递问题”。这是在问Java中的值传递机制。Java值传递语言,这意味着在方法调用时,参数是原始值的副本。对于基本类型,传递的是值的副本;对于对象引用,传递的是引用的副本。 我需要详细解释Java值传递机制,并提供代码示例来演示。代码应该用Java编写,并使用Markdown格式包裹。 回答结构: 1. **回答问题**:解释Java值传递概念。 2. **给出解释**:详细说明为什么Java值传递,并提供代码示例和解释。 3. **相关代码**:提供Java代码来展示值传递的行为。 4. **提出相关问题**:在最后,按照指定格式提出相关问题。 ### 关键点: - **基本类型(如int, double)**:传递的是值的副本。方法内部修改不会影响原始值。 - **对象引用**:传递的是引用的副本。这意味着方法内部可以修改对象的状态,但不能改变原始引用(即不能重新分配对象)。 代码示例: - 示例1:基本类型值传递。 - 示例2:对象引用值传递。 ### 回答大纲: 1. **介绍**:Java值传递语言。所有参数都是按值传递。 2. **基本类型示例**:展示一个方法修改基本类型参数,但原始值不变。 3. **对象引用示例**:展示一个方法修改对象的状态(如字段),但尝试重新分配引用时,原始引用不变。 4. **解释**:为什么Java值传递,以及常见误解。 5. **相关问题**:按照格式提出4个相关问题。 ### 代码示例: **示例1:基本类型值传递** ```java public class ValuePassingDemo { public static void main(String[] args) { int number = 10; System.out.println("Before method call: " + number); // Output: 10 modifyPrimitive(number); System.out.println("After method call: " + number); // Output: 10 } public static void modifyPrimitive(int num) { num = 20; System.out.println("Inside method: " + num); // Output: 20 } } ``` **示例2:对象引用值传递** ```java class MyObject { int value; MyObject(int value) { this.value = value; } } public class ReferencePassingDemo { public static void main(String[] args) { MyObject obj = new MyObject(10); System.out.println("Before method call: " + obj.value); // Output: 10 modifyReference(obj); System.out.println("After method call: " + obj.value); // Output: 20 // But if we try to reassign the reference reassignReference(obj); System.out.println("After reassign: " + obj.value); // Output: 20 (unchanged) } public static void modifyReference(MyObject param) { param.value = 20; // Modifies the object's state } public static void reassignReference(MyObject param) { param = new MyObject(30); // Reassigns the copy of the reference, not the original System.out.println("Inside reassign: " + param.value); // Output: 30 } } ``` ### 解释: - 在第一个示例中,`modifyPrimitive` 方法接收 `number` 的副本,修改副本不影响原始值。 - 在第二个示例中,`modifyReference` 方法接收引用的副本,但通过该引用修改了对象的状态,所以原始对象被改变。然而,`reassignReference` 方法尝试重新分配引用,但由于是副本,原始引用不变。 ### 相关问题: 按照格式,提出4个相关问题: 1. Java中基本类型和引用类型在传递时的区别。 2. 如何模拟引用传递或指针传递在Java中。 3. Java中的String对象为什么在方法中修改不会影响原始值。 4. 值传递和引用传递在其他语言(如C++)中的区别。 最后,确保回答以指定格式结束。</think>### Java 值传递问题详解 在 Java 中,所有参数传递都是**值传递(Pass by Value)**。这意味着: - **基本类型(如 int, double, boolean)**:传递的是值的副本。方法内部修改不会影响原始变量。 - **引用类型(如对象、数组)**:传递的是引用的副本(即内存地址的副本)。方法内部可以修改对象的状态,但**不能改变原始引用的指向**(例如,不能通过参数重新分配对象)。 以下代码示例演示了 Java值传递行为: #### 示例 1: 基本类型值传递 ```java public class PrimitivePassingDemo { public static void main(String[] args) { int num = 10; System.out.println("Before modify: " + num); // 输出: 10 modifyPrimitive(num); System.out.println("After modify: " + num); // 输出: 10 (未改变) } // 方法接收基本类型参数的副本 public static void modifyPrimitive(int value) { value = 20; // 修改副本,不影响原始变量 System.out.println("Inside method: " + value); // 输出: 20 } } ``` **解释**: - `num` 是基本类型,传递时创建副本 `value`。 - 方法内修改 `value` 不影响原始 `num`,因为两者是独立的内存空间。 #### 示例 2: 引用类型值传递 ```java class MyObject { int data; MyObject(int data) { this.data = data; } } public class ReferencePassingDemo { public static void main(String[] args) { MyObject obj = new MyObject(10); System.out.println("Before modify: " + obj.data); // 输出: 10 modifyObjectState(obj); // 修改对象状态 System.out.println("After state modify: " + obj.data); // 输出: 20 reassignObject(obj); // 尝试重新分配引用 System.out.println("After reassign: " + obj.data); // 输出: 20 (未改变) } // 1. 修改对象状态:通过引用副本操作原始对象 public static void modifyObjectState(MyObject param) { param.data = 20; // 修改对象字段,影响原始对象 } // 2. 重新分配引用:只影响副本,不影响原始引用 public static void reassignObject(MyObject param) { param = new MyObject(30); // 副本指向新对象,原始引用不变 System.out.println("Inside reassign: " + param.data); // 输出: 30 } } ``` **解释**: - **`modifyObjectState` 方法**: `param` 是原始引用 `obj` 的副本,两者指向同一对象。修改 `param.data` 会改变原始对象的状态。 - **`reassignObject` 方法**: `param = new MyObject(30)` 只让副本指向新对象,原始引用 `obj` 仍指向原对象。因此原始对象未被替换。 #### 关键结论: 1. **值传递本质**:Java 始终传递值的副本(基本类型是数据副本,引用类型是地址副本)。 2. **常见误解**: - 修改引用类型对象的状态 ≠ 改变原始引用。 - 无法通过方法参数让原始引用指向新对象(需通过返回值实现)。 3. **与引用传递的区别**: 真正的引用传递(如 C++ 的 `&`)允许方法直接修改原始变量。Java 不支持此机制。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值