Java中是值传递和引用传递

值传递 / 引用传递
值传递：就是在方法调用的时候，实参是将自己的一份拷贝赋给形参，在方法内，对该参数值的修改不影响原来的实参。

引用传递：是在方法调用的时候，实参将自己的地址传递给形参，此时方法内对该参数值的改变，就是对该实参的实际操作。

Java中只有值传递
首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。

按值调用（call by value）：表示方法接收的是调用者提供的值。

按引用调用（call by reference）：表示方法接收的是调用者提供的变量地址。

它用来描述各种程序设计语言（不只是 Java)中方法参数传递方式。

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

swap( ) 场景
要求写一个函数交换int类型的a和b的值

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

如果我们这么写：

public class test{
  
    public static void main(String[] args) {
          int A = 2;
          int B = 3;
          swap(A, B);
        System.out.println(A);
        System.out.println(B);
    }
    
      public static void swap(int a, int b){
        int tmp = a;
        a = b;
        b = tmp;
        }
}

运行结果为：

2
3

发现A和B的值并没有交换，为什么呢?

因为Java中采用的是值传递，也就是说执行swap(int a, int b)时，这里的参数a和b，只是A和B的副本，函数的运行结果并没有改变原来A和B的值。

那么采用Integer呢？

如果将上面的int类型转变为Integer，swap(Integer a, Integer b)会不会实现交换功能呢?

public class test{
  
    public static void main(String[] args) {
          Integer A = 2;
          Integer B = 3;
          swap(A, B);
        System.out.println(A);
        System.out.println(B);
    }
    
      public static void swap(Integer a, Integer b){
        Integer tmp = a;
        a = b;
        b = tmp;
        }
}

运行结果为：

2
3

可见还是没有完成交换！

去查看Integer的源码：

public final class Integer extends Number implements Comparable<Integer> {}

可以看到Integer使用final修饰的int进行存储。final修饰的变量不能被重新赋值，所以操作参数传递变量时，实际上是操作变量对象的副本（Java中的包装类型都是默认使用这种方式实现的，使用拷贝副本的方式提升效率和减少内存消耗）。

如果换作是数组呢？

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

这里方法array是对象的引用arr的拷贝，而不是对象本身的拷贝，因此， array 和 arr 指向的是同一个数组对象。

如果换做是一般对象呢？

很多程序设计语言（特别是 C++ 和 Pascal)提供了两种参数传递的方式：值调用和引用调用。

有些程序员（甚至本书的作者）认为 Java 程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。

class User {
    private String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

测试：

public class test{
        public static void main(String[] args) {
        User A = new User("ali");
        User B = new User("bd");
        System.out.println("交换前name：" + A + "-->" + B);
        swap(a,b);
        System.out.println("交换后name：" + A + "-->" + B);
    }

    private static void swap(User a, User b) {
        User tmp = a;
        a = b;
        b = tmp;
    }
}

运行结果为：

交换前name：ali-->bd
交换后name：ali-->bd

发现还是没有交换！

所以到底有没有交换，主要是看它修改的是变量（引用）还是修改的堆里面的对象。

交换前：

交换后：

 

 

通过上面两张图可以很清晰的看出： 方法并没有改变存储在变量 A 和 B 中的对象引用。swap() 方法的参数 a 和 b 被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝。

那么到底该如何实现交换两个变量的值呢？

用容器（或者数组）
例如：

public class test{

    public static void main(String[] args) {
        int[] arr = {2, 3};
        int A = arr[0];
        int B = arr[1];
        swap(arr, 0, 1);
        A = arr[0];
        B = arr[1];
        System.out.println(A);
        System.out.println(B);
    }

    public static void swap(int[] arr, int a, int b){
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }
}

运行结果为：

3
2

用反射

public static void swap(Integer a, Integer b) throws Exception {
    Field field = Integer.class.getDeclaredField("value");
    field.setAccessible(true);   //设置可以访问成员的私有不可变的变量
    Integer tmp =new Integer(a.intValue());
    field.set(a, b.intValue());
    field.set(b, tmp);
}