首先,我们要认识到一点Java中方法参数的传递都是按值调用的,方法得到的是所有参数值的一个拷贝,它并不能修改传递给它的参数变量的值。下面我们就来详细了解一下,为什么会这么说?
方法参数有两种类型:
下面我们分别来分析这两种情况。
/**
* 方法参数为基础数据类型
*/
public class ParamTest1 {
public static void main(String[] args) {
int number = 10;
changeValue(number);
System.out.println(number);
}
public static void changeValue(int x) {
x = x + 3;
}
}
打印结果为10,并没有发生任何的改变,这是为什么呢?我们来看一下具体的执行流程:
也就是说,一个方法不可能修改一个基本数据类型的参数。
对象引用作为参数的话,是可以修改参数的状态的,但是修改的是这个对象引用的地址值所对应的对象的状态,而不是修改了对象的地址值,也就是说实际上方法参数是对象的话,虽然可以修改参数的状态,但是并没有修改参数的值。 当然,对象引用中又分为两种情况:
/**
* 方法参数为对象时,修改该对象的状态
*/
public class ParamChangeTest {
public static void main(String[] args) {
User user = new User("Pony马",20000.00);
System.out.println("方法调用前,salary的值为:" + user.getSalary());
tripSalry(user);
System.out.println("方法调用后,salary的值为:" + user.getSalary());
}
public static void tripSalry(User u) {
u.raiseSalary(20);
System.out.println("方法结束,salary的值为: " + u.getSalary());
}
}
class User {
private String name;
private double salary;
public User(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void raiseSalary(double byPercent) {
double raise = salary * byPercent / 100;
salary += raise;
}
}
打印结果为:
方法调用前,salary的值为:20000.0
方法结束,salary的值为: 24000.0
方法调用后,salary的值为:24000.0
我们来看一下,这个方法调用的过程:
/**
* 方法参数为对象时,修改该对象的状态
*/
public class ParamChangeTest {
public static void main(String[] args) {
User user_a = new User("Pony马", 20000.00);
User user_b = new User("Jacky马", 30000.00);
System.out.println("方法调用前,user_a的姓名:" + user_a.getName());
System.out.println("方法调用前,user_b的姓名:" + user_b.getName());
exchange(user_a, user_b);
System.out.println("方法调用后,user_a的姓名:" + user_a.getName());
System.out.println("方法调用后,user_b的姓名:" + user_b.getName());
}
public static void exchange(User a, User b) {
User temp = a;
a = b;
b = temp;
System.out.println("方法结束,a的姓名:" + a.getName());
System.out.println("方法结束,b的姓名:" + b.getName());
}
}
class User {
private String name;
private double salary;
public User(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void raiseSalary(double byPercent) {
double raise = salary * byPercent / 100;
salary += raise;
}
}
打印结果为:
方法调用前,user_a的姓名:Pony马
方法调用前,user_b的姓名:Jacky马
方法结束,a的姓名:Jacky马
方法结束,b的姓名:Pony马
方法调用后,user_a的姓名:Pony马
方法调用后,user_b的姓名:Jacky马
这里可以看到,方法并没有改变存储在变量usera和变量userb中的地址值,exchange方法的参数a和b被初始化为两个地址值的拷贝,这个方法交换的是这两个拷贝,但是在方法结束之后,参数变量a和b被释放掉了,所以原来的变量usera和userb仍然引用这个方法之前所引用的对象。
Java中方法参数的使用情况: