程序设计语言将实参传递给方法（或函数）的方式分为两种：

• 值传递：方法接收的是实参值的拷贝，会创建副本。
• 引用传递：方法接收的直接是实参所引用的对象在堆中的地址，不会创建副本，对形参的修改将影响到实参。

很多程序设计语言（比如 C++、 Pascal )提供了两种参数传递的方式，不过，在 Java 中只有值传递。

那我们常听的Java中的引用传递是什么？

在方法调用时，传递的参数是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。（本质上还是值传递）
传递的是一个拷贝，即副本。也就是说，对于一个参数传递，存在两个地址指向同一个内存空间。

传递基本数据类型 

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

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

通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看案例 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

解析：

看了这个案例很多人肯定觉得 Java 对引用类型的参数采用的是引用传递。

实际上，并不是的，这里传递的还是值，不过，这个值是实参的地址罢了！

也就是说 change 方法的参数拷贝的是 arr （实参）的地址，因此，它和 arr 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。

为了更强有力地反驳 Java 对引用类型的参数采用的不是引用传递，我们再来看下面这个案例！

交换引用数据类型

代码：

public class Person {
    private String name;
   // 省略构造函数、Getter&Setter方法
}

public static void main(String[] args) {
    Person xiaoZhang = new Person("小张");
    Person xiaoLi = new Person("小李");
    swap(xiaoZhang, xiaoLi);
    System.out.println("xiaoZhang:" + xiaoZhang.getName());
    System.out.println("xiaoLi:" + xiaoLi.getName());
}

public static void swap(Person person1, Person person2) {
    Person temp = person1;
    person1 = person2;
    person2 = temp;
    System.out.println("person1:" + person1.getName());
    System.out.println("person2:" + person2.getName());
}

 输出：

person1:小李
person2:小张
xiaoZhang:小张
xiaoLi:小李

怎么回事？？？两个引用类型的形参互换并没有影响实参啊！

swap 方法的参数 person1 和 person2 只是拷贝的实参 xiaoZhang 和 xiaoLi 的地址。因此， person1 和 person2 的互换只是拷贝的两个地址的互换罢了，并不会影响到实参 xiaoZhang 和 xiaoLi 。

不光String类型是这样，自己定义的Java类也会是这样

代码：

public class Main {
    public static void main(String[] args) {
        user user1 = new user("小明",20);
        user user2 = new user("小红",18);
        swap(user1,user2);
        System.out.println(user1.toString());
        System.out.println(user2.toString());
    }
    public static void swap(user user1,user user2){
        user temp = user2;
        user2 = user1;
        user1 = temp;
    }
}
class user{
    String name;
    int age;

    public user(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "user{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

输出： 

user{name='小明', age=20}
user{name='小红', age=18}

String类型传递

这里的String类型传递比较特殊，单拿出来说
先说结论，String类型传递与基本数据类型的传递效果相似。
说明：
String类对象一旦创建，其内容不可更改:
String类的所有方法都不会改变String类对象内容，要改变String类对象的值就必须创建一个新的String对象。
也就是说，当进行参数传递时，如果方法内对String类对象的值进行了修改，那么实际上是创建了一个新的String类对象，然后让原来的变量指向它而已。但是这个“原来的变量”是一份拷贝副本，只是一开始创建的时候与主方法中的传递的值相同而已，现在改变之后，两者就毫无关系了。
代码：

public class TestTransOfValue 
{public static void main(String args[])
 { double val;
    StringBuffer sb1, sb2;
    String sb3;
    char s[]={'a','p','p','l','e'};
    val = 5.8;
    sb1 = new StringBuffer("apples");
    sb2=new StringBuffer("pears");
    sb3 = new String("pear");
    modify(val, sb1, sb2,sb3,s);
    System.out.println(val);
    System.out.println(sb1);
    System.out.println(sb2);
    System.out.println(sb3);
    System.out.println(s);
}
public static void modify(double a, StringBuffer r1,
                         StringBuffer r2,String r3,char s[] )
  { a = 6.8;  
    r1.append(" taste good");
    r2=null;
    r3="banana";
    s[2]='R';       }
}

运行结果：

5.8
apples taste good
pears
pear
apRle

解释：

1. double是基本数据类型，值拷贝的两者直接互不影响。所以modify方法内对a的操作不影响主方法的val的值 因此val=5.8
2. sb1为StringBuffer型，不属于基本类型，因此是引用传递。r1.append()修改了r1地址对应的内存空间的值，因此sb1的值改变了
3. sb2同样是StringBuffer型，属于引用传递。但r2=null是修改的r2的地址的值而不是r2地址指向的内存空间的值，因此sb2指向的还是原来指向的内存空间，且内存空间的值未被改变。
4. sb3为String类型，属于引用传递。但是String类型是一个特殊的类，在方法内改变String的值并不能改变主方法中的String的值，r3=“banana"是创建了一个banana字符串然后让方法内的变量r3指向"banana”，但方法内的r3和主方法中的r3不是同一个变量,因此String仍然是pear
5. char数组为引用传递，且s[2]=‘R’，确实修改的是内存空间的值，因此char数组的值被改变