Java 引用传递

Java 引用传递1、Java 应用程序有且仅有的一种参数传递机制,即按值传递2、按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本3、按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址(副本),而不是值的副本 代码: 结果: 李四 张三 张三 李四 虽然形参对

1、Java 应用程序有且仅有的一种参数传递机制,即按值传递
2、按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本
3、按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址(副本),而不是值的副本

Java 引用传递

代码:

public class Main {
    public static void main(String[] args) {
        Employee worker=new Employee("张三");
        Employee manager=new Employee("李四");
        swap(worker,manager);
        System.out.println(worker.name+" "+manager.name);  
    }
}
  class Employee {

    public String name=null;

    public Employee(String n){
        this.name=n;
    }
    //将两个Employee对象交换
    public static void swap(Employee e1,Employee e2){
        Employee temp=e1;
        e1=e2;
        e2=temp;
        System.out.println(e1.name+" "+e2.name); 
    }
}

结果:

Java 引用传递
Java 引用传递

李四 张三
张三 李四

View Code

虽然形参对象e1,e2的内容交换了,但实参对象worker,manager并没有互换内容。这里面最重要的原因就在于形参e1,e2是实参worker,manager的地址拷贝。

如果大家对JVM内存管理中Java栈 的局部变量区 ,就很好理解上面这句话。在JVM运行上面的程序时,运行main方法和swap方法,会在Java栈中先后push两个叫做栈帧 的内存空间。

main栈帧中有一块叫局部变量区的内存用来存储实参对象worker和manager的引用。

而swap栈帧中的局部变量区则存储了形参对象e1和e2的引用。

虽然e1和e2的引用值分别与worker和manager相同,但是它们占用了不同的内存空间。

当e1和e2的引用发生交换时,下面的图很清晰的看出完全不会影响worker和manager的引用值。

Java 引用传递

 

String,Integer, Double等immutable类型因为没有提供自身修改的函数,每次操作都是新生成一个对象,所以要特殊对待。可以认为是传值。

Integer 和 String 一样。保存value的类变量是Final属性,无法被修改,只能被重新赋值/生成新的对象。 

当Integer 做为方法参数传递进方法内时,对其的赋值都会导致 原Integer 的引用被 指向了方法内的栈地址,失去了对原类变量地址的指向。对赋值后的Integer对象做得任何操作,都不会影响原来对象。

 

代码:

public class Main {
    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]);
    }
}

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;
    }
}

结果:

Java 引用传递
Java 引用传递

对象交换前: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

View Code

 说明:不管是对象、基本类型还是对象数组、基本类型数组,在函数中都不能改变其实际地址但能改变其中的内容。

上面的代码,对数组对象Person[],int[]进行切换,不会发生变化,但是对p1[1],p2[1],x[1],y[1]进行置换,就会发现可以改变数组的内容。

http://www.jb51.net/article/80188.htm

http://blog.csdn.net/yangliuy/article/details/43230681

http://www.cnblogs.com/lanxuezaipiao/p/3371224.html

今天的文章Java 引用传递分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/56951.html

(0)
编程小号编程小号
上一篇 2023-08-26
下一篇 2023-08-26

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注