java 值和引用_Java中的值传递和引用传递

如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的 地址，所以不会改变参数的值。

例子：

packagecom.demo.test;public classEmployee {privateString name;private doublesalary;public Employee(String name,doublesalary){this.name =name;this.salary =salary;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public doublegetSalary() {returnsalary;

}public void setSalary(doublesalary) {this.salary =salary;

}

}

packagecom.demo.test;public classParamTest {public static voidmain(String[] args) {/*** Test 1: Methods can't modify numeric parameters*/System.out.println("Testing tripleValue:");double percent = 10;

System.out.println("Before: percent=" +percent);

tripleValue(percent);

System.out.println("After: percent=" +percent);/*** Test 2: Methods can change the state of object parameters*/System.out.println("\nTesting tripleSalary:");

Employee harry= new Employee("Harry", 50000);

System.out.println("Before: salary=" +harry.getSalary());

tripleSalary(harry);

System.out.println("After: salary=" +harry.getSalary());/*** Test 3: Methods can't attach new objects to object parameters*/System.out.println("\nTesting swap:");

Employee a= new Employee("Alice", 70000);

Employee b= new Employee("Bob", 60000);

System.out.println("Before: a=" +a.getName());

System.out.println("Before: b=" +b.getName());

swap(a, b);

System.out.println("After: a=" +a.getName());

System.out.println("After: b=" +b.getName());

}private static voidswap(Employee x, Employee y) {

Employee temp=x;

x=y;

y=temp;

System.out.println("End of method: x=" +x.getName());

System.out.println("End of method: y=" +y.getName());

}private static voidtripleSalary(Employee x) {

x.setSalary(x.getSalary()*3);

System.out.println("End of method: salary=" +x.getSalary());

}private static void tripleValue(doublex) {

x= 3 *x;

System.out.println("End of Method X= " +x);

}

}

运行结果：

Testing tripleValue:

Before: percent=10.0End of Method X= 30.0After: percent=10.0Testing tripleSalary:

Before: salary=50000.0End of method: salary=150000.0After: salary=150000.0Testing swap:

Before: a=Alice

Before: b=Bob

End of method: x=Bob //可见引用的副本进行了交换

End of method: y=Alice

After: a=Alice //引用本身没有交换

After: b=Bob

首先要说明的是java中是没有指针的，java中只存在值传递，只存在值传递！！！  然而我们经常看到对于对象(数组，类，接口)的传递似乎有点像引用传递，可以改变对象中某个属性的值。但是不要被这个假象所蒙蔽，实际上这个传入函数的值是对象引用的拷贝，即传递的是引用的地址值，所以还是按值传递。

示例1：

public classTest {public static void change(inta){

a=50;

}public static voidmain(String[] args) {int a=10;

System.out.println(a);

change(a);

System.out.println(a);

}

}

很显然输出的 是10，10。传递的是值的一份拷贝，这份拷贝与原来的值没什么关系。

内存分析：

示例2：

public classTest {public static void change(int[]a){

a[0]=50;

}public static voidmain(String[] args) {int []a={10,20};

System.out.println(a[0]);

change(a);

System.out.println(a[0]);

}

}

显然输出结果为10   50。实际传递的是引用的地址值。

内存分析：

示例3：

classEmp {public intage;

}public classTest {public static voidchange(Emp emp)

{

emp.age= 50;

emp= new Emp();//再创建一个对象

emp.age=100;

}public static voidmain(String[] args) {

Emp emp= newEmp();

emp.age= 100;

System.out.println(emp.age);

change(emp);

System.out.println(emp.age);

System.out.println(emp.age);

}

}

输出为：100  50  50.

内存分析：

对于String类：

public classTest {public static voidchange(String s){

s="zhangsan";

}public static voidmain(String[] args) {

String s=new String("lisi");

System.out.println(s);

change(s);

System.out.println(s);

}

}

输出为：lisi   lisi，由于String类是final修饰的，不可变，它会在内存中在开辟一块新空间。