Java中只有值传递没有引用传递

当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。

在java中，新创建的实体对象在堆内存中开辟空间，而引用变量在栈内存中开辟空间
值传递的精髓是：传递的是存储单元中的内容，而非地址或者引用！

对象被值传递，意味着传递了对象的一个副本。因此，就算是改变了对象副本，也不会影响源对象的值。 对象被引用传递，意味着传递的并不是实际的对象，而是对象的引用。因此，外部对引用对象所做的改变会反映到所有的对象上。

package test;

/**
 * @description Java中没有引用传递只有值传递
 * 
 * 
 */
class Person {

    private String name;

    private String sex;

    public Person(String x, String y) {
        this.name = x;
        this.sex = y;
    }

    // 重写toString()方法，方便输出
    public String toString() {

        return name + " " + sex;
    }

    // 交换对象引用
    public static void swapObject(Person p1, Person p2) {
        Person tmp = p1;
        p1 = p2;
        p2 = tmp;
    }

    // 交换基本类型
    public static void swapInt(int a, int b) {
        int tmp = a;
        a = b;
        b = tmp;
    }

    // 交换对象数组
    public static void swapObjectArray(Person[] p1, Person[] p2) {
        Person[] tmp = p1;
        p1 = p2;
        p2 = tmp;
    }

    // 交换基本类型数组
    public static void swapIntArray(int[] x, int[] y) {
        int[] tmp = x;
        x = y;
        y = tmp;
    }

    // 改变对象数组中的内容
    public static void changeObjectArray(Person[] p1, Person[] p2) {
        Person tmp = p1[1];
        p1[1] = p2[1];
        p2[1] = tmp;

        // 再将p1[1]修改
        Person p = new Person("wjl", "male");
        p1[1] = p;
    }

    // 改变基本类型数组中的内容
    public static void changeIntArray(int[] x, int[] y) {
        int tmp = x[1];
        x[1] = y[1];
        y[1] = tmp;

        x[1] = 5;
    }
}

public class ByValueTest {

    public static void main(String[] args) {

        // 建立并构造两个对象
        Person p1 = new Person("Alexia", "female");
        Person p2 = new Person("Edward", "male");

        System.out.println("对象交换前：p1 = " + p1.toString());
        System.out.println("对象交换前：p2 = " + p2.toString());

        // 交换p1对象和p2对象
        Person.swapObject(p1, p2);
        // 从交换结果中看出，实际对象并未交换
        System.out.println("\n对象交换后：p1 = " + p1.toString());
        System.out.println("对象交换后：p2 = " + p2.toString());

        // 建立两个对象数组
        Person[] arraya = new Person[2];
        Person[] arrayb = new Person[2];

        // 分别构造数组对象
        arraya[0] = new Person("Alexia", "female");
        arraya[1] = new Person("Edward", "male");
        arrayb[0] = new Person("jmwang", "female");
        arrayb[1] = new Person("hwu", "male");

        System.out.println('\n' + "对象数组交换前：arraya[0] = "
                + arraya[0].toString() + ", arraya[1] = "
                + arraya[1].toString());
        System.out.println("对象数组交换前：arrayb[0] = "
                + arrayb[0].toString() + ", arrayb[1] = "
                + arrayb[1].toString());

        // 交换这两个对象数组
        Person.swapObjectArray(arraya, arrayb);
        System.out.println('\n' + "对象数组交换后：arraya[0] = "
                + arraya[0].toString() + ", arraya[1] = "
                + arraya[1].toString());
        System.out.println("对象数组交换后：arrayb[0] = "
                + arrayb[0].toString() + ", arrayb[1] = "
                + arrayb[1].toString());

        // 建立两个普通数组
        int[] a = new int[2];
        int[] b = new int[2];

        // 给数组个元素赋值
        for (int i = 0; i < a.length; i++) {
            a[i] = i;
            b[i] = i + 1;
        }

        System.out.println('\n' + "基本类型数组交换前：a[0] = " + a[0] + ", a[1] = " + a[1]);
        System.out.println("基本类型数组交换前：b[0] = " + b[0] + ", b[1] = " + b[1]);

        // 交换两个基本类型数组
        Person.swapIntArray(a, b);
        System.out.println('\n' + "基本类型数组交换后：a[0] = " + a[0] + ", a[1] = " + a[1]);
        System.out.println("基本类型数组交换后：b[0] = " + b[0] + ", b[1] = " + b[1]);

        // 改变对象数组的内容
        Person.changeObjectArray(arraya, arrayb);
        System.out.println('\n' + "对象数组内容交换并改变后：arraya[1] = " + arraya[1].toString());
        System.out.println("对象数组内容交换并改变后：arrayb[1] = " + arrayb[1].toString());

        // 改变基本类型数组的内容
        Person.changeIntArray(a, b);
        System.out.println('\n' + "基本类型数组内容交换并改变后：a[1] = " + a[1]);
        System.out.println("基本类型数组内容交换并改变后：b[1] = " + b[1]);
    }
}

运行结果：

对象交换前：p1 = Alexia female
对象交换前：p2 = Edward male

对象交换后：p1 = Alexia female
对象交换后：p2 = Edward male

对象数组交换前：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换前：arrayb[0] = jmwang female, arrayb[1] = hwu male

对象数组交换后：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换后：arrayb[0] = jmwang female, arrayb[1] = hwu male

基本类型数组交换前：a[0] = 0, a[1] = 1
基本类型数组交换前：b[0] = 1, b[1] = 2

基本类型数组交换后：a[0] = 0, a[1] = 1
基本类型数组交换后：b[0] = 1, b[1] = 2

对象数组内容交换并改变后：arraya[1] = wjl male
对象数组内容交换并改变后：arrayb[1] = Edward male

基本类型数组内容交换并改变后：a[1] = 5
基本类型数组内容交换并改变后：b[1] = 1