当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。
首先要说明的是java中是没有指针的，java中只存在值传递，只存在值传递。 然而我们经常看到对于对象（数组，类，接口）的传递似乎有点像引用传递，可以改变对象中某个属性的值。但是不要被这个假象所蒙蔽，实际上这个传入函数的值是对象引用的拷贝，即传递的是引用的地址值，所以还是按值传递。不是将对象本身传递给方法，而是将对象的的引用或者说对象的首地址传递给方法，引用本身是按值传递的；也就是说，讲引用的副本传递给方法（副本就是说明对象此时有两个引用了），通过对象的引用，方法可以直接操作该对象（当操作该对象时才能改变该对象，而操作引用时源对象是没有改变的）。
java中数据类型分为基本数据类型和引用数据类型。
- 基本数据类型
- 整型：byte，short，int，long
- 浮点型：float，double
- 字符型：char
- 布尔型：boolean
- 引用数据类型
- 数组
- 类
- 接口
方法的参数分为实际参数，和形式参数。
- 形式参数：定义方法时写的参数。
- 实际参数：调用方法时写的具体数值。
一般情况下，在数据做为参数传递的时候，基本数据类型是值传递，引用数据类型是“引用传递（地址传递）”。
Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。
如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.
如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的 值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。
例1：
public class ParamTest {
2 public static void main(String[] args){
3 /**
4 * Test 1: Methods can't modify numeric parameters
5 */
6 System.out.println("Testing tripleValue:");
7 double percent = 10;
8 System.out.println("Before: percent=" + percent);
9 tripleValue(percent);
10 System.out.println("After: percent=" + percent);
11
12 /**
13 * Test 2: Methods can change the state of object parameters
14 */
15 System.out.println("\nTesting tripleSalary:");
16 Employee harry = new Employee("Harry", 50000);
17 System.out.println("Before: salary=" + harry.getSalary());
18 tripleSalary(harry);
19 System.out.println("After: salary=" + harry.getSalary());
20
21 /**
22 * Test 3: Methods can't attach new objects to object parameters
23 */
24 System.out.println("\nTesting swap:");
25 Employee a = new Employee("Alice", 70000);
26 Employee b = new Employee("Bob", 60000);
27 System.out.println("Before: a=" + a.getName());
28 System.out.println("Before: b=" + b.getName());
29 swap(a, b);
30 System.out.println("After: a=" + a.getName());
31 System.out.println("After: b=" + b.getName());
32 }
33
34 private static void swap(Employee x, Employee y) {
35 Employee temp = x;
36 x=y;
37 y=temp;
38 System.out.println("End of method: x=" + x.getName());
39 System.out.println("End of method: y=" + y.getName());
40 }
41
42 private static void tripleSalary(Employee x) {
43 x.raiseSalary(200);//x被赋予harry值的拷贝，这里是一个对象的引用,raiseSalary方法应用于这个应用。x和harry指向同一对象，该对象的值改变了，此方法结束后，x不再使用，harry指向的那个对象值变了44 System.out.println("End of method: salary=" + x.getSalary());
45 }
46
47 private static void tripleValue(double x) {
48 x=3*x;
49 System.out.println("End of Method X= "+x);
50 }
51 }
显示结果：
Testing tripleValue:
Before: percent=10.0
End of Method X= 30.0
After: percent=10.0
Testing tripleSalary:
Before: salary=50000.0
End of method: salary=150000.0
After: salary=150000.0
Testing swap:
Before: a=Alice
Before: b=Bob
End of method: x=Bob //可见引用的副本进行了交换
End of method: y=Alice
After: a=Alice //引用本身没有交换
After: b=Bob
//将对象a,b的拷贝分别赋值给x,y，此时a和x指向同一对象，b和y指向同一对象;swap方法体完成x,y的交换,此时a,b并没有变化;方法执行完成，x和y不再使用，a依旧指向new Employee("Alice", 70000),b指向new Employee("Bob", 60000);
//swap执行完成，x,y不再使用,回到创建时状态。从这个过程中可以看出，Java对对象采用的不是引用调用，实际上，对象引用进行的是值传递。
总结一下java中方法参数的使用情况：
- 一个方法不能修改一个基本数据类型的参数(即数值型和布尔型)
- 一个方法可以改变一个对象参数的状态
- 一个方法不能让对象参数引用一个新的对象
例2：
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 = 201解析：
流程：
- 主函数进栈，num1、num2初始化。
- 调用swap方法，swap( )进栈，将num1和num2的值，复制一份给a和b。
- swap方法中对a、b的值进行交换。
- swap方法运行完毕，a、b的值已经交换。
- swap方法弹栈。
- 主函数弹栈。
在swap方法中，a、b的值进行交换，并不会影响到num1、num2。因为，a、b中的值，只是从num1、num2的复制过来的。也就是说，a、b相当于num1、num2的副本，副本的内容无论怎么修改，都不会影响到原件本身。
例3：
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[0]);
}
//将数组的第一个元素变为0
public static void change(int[] array) {
int len = array.length;
array[0] = 0;
}运行的结果是：0
解析：
流程：
- 主函数进栈，int[] arr初始化。
- 调用change方法，change( )进栈，将arr的地址值，复制一份给array。
- change方法中，根据地址值，找到堆中的数组，并将第一个元素的值改为0。
- change方法运行完毕，数组中第一个元素的值已经改变。
- change方法弹栈。
- 主函数弹栈。
调用change()的时候，形参array接收的是arr地址值的副本。并在change方法中，通过地址值，对数组进行操作。change方法弹栈以后，数组中的值已经改变。main方法中，打印出来的arr[0]也就从原来的1变成了0.无论是主函数，还是change方法，操作的都是同一个地址值对应的数组。
例4：
public static void main(String[] args) {
String str = "AAA";
change(str);
System.out.println(str);
}
public static void change(String s) {
s = "abc";
}运行的结果是：
AAA解析：
String是一个类，类是引用数据类型，做为参数传递的时候，应该是引用传递。但是从结果看起来却是值传递。
String的API中有这么一句话：“their values cannot be changed after they are created”，意思是：String的值在创建之后不能被更改。
API中还有一段： String str = "abc";等效于： char data[] = {'a', 'b', 'c'}; String str = new String(data); 也就是说：对String对象str的任何修改等同于重新创建一个对象，并将新的地址值赋值给str。上述代码等价于：
public static void main(String[] args) {
String str1 = "AAA";
change(str1);
System.out.println(str1);
}
public static void change(String s) {
char data[] = {'a', 'b', 'c'}
String str = new String(data);
s = str;
}解析：
流程：
- 主函数进栈，str1初始化。
- 调用change方法，change( )进栈，将str1的地址值，复制一份给s。
- change方法中，重现创建了一个String对象”abc”，并将s指向了新的地址值。
- change方法运行完毕，s所指向的地址值已经改变。
- change方法弹栈。
- 主函数弹栈。
String对象做为参数传递时，走的依然是引用传递，只不过String这个类比较特殊。
String对象一旦创建，内容不可更改。每一次内容的更改都是重现创建出来的新对象。
当change方法执行完毕时，s所指向的地址值已经改变。而s本来的地址值就是copy过来的副本，所以并不能改变str1的值。
类似例：
class Person {
String name;
public Person(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person("张三");
change(p);
System.out.println(p.name);
}
public static void change(Person p) {
Person person = new Person("李四");
p = person;
}
}运行的结果是：
张三总结
- 值传递的时候，将实参的值，copy一份给形参。
- 引用传递的时候，将实参的地址值，copy一份给形参。
也就是说，不管是值传递还是引用传递，形参拿到的仅仅是实参的副本，而不是实参本身。
