Java中的参数传递

程序设计语言将实参传递给方法(或函数)的方式分为两种:

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

很多程序设计语言(比如 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() 方法中,ab 的值进行交换,并不会影响到 num1num2。因为,ab 的值,只是从 num1num2 的复制过来的。也就是说,a、b 相当于 num1num2 的副本,副本的内容无论怎么修改,都不会影响到原件本身。

通过上面例子,我们已经知道了一个方法不能修改一个基本数据类型的参数,而对象引用作为参数就不一样,请看案例 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 方法的参数 person1person2 只是拷贝的实参 xiaoZhangxiaoLi 的地址。因此, person1person2 的互换只是拷贝的两个地址的互换罢了,并不会影响到实参 xiaoZhangxiaoLi

不光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数组的值被改变
     
  • 55
    点赞
  • 33
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值