基本类型的参数的传递

基本类型包括整型，浮点型，布尔型，字符型。

首先定义一个简单的类：

1
2
3
4
5
6
7
8
9
class Person{
    private int age;
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        this.age = age;
    }
}

看一下调用情况：

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        int n = 15; // n的值为15
        p.setAge(n); // 传入n的值
        System.out.println(p.getAge()); // 15
        n = 20; // n的值改为20
        System.out.println(p.getAge()); // 15
    }
}

从结果可以看出，修改外部变量n，并不影响实例p的age字段，原因是setAge()方法获得的参数，是复制了n的值，因此，p.age和局部变量n互不影响。

结论：基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。

引用类型的参数的传递

数组和String都是引用类型。

同样先定义一个类：

1
2
3
4
5
6
7
8
9
class Person {
    private String[] name;
    public String getName() {
        return this.name[0] + " " + this.name[1];
    }
    public void setName(String[] name) {
        this.name = name;
    }
}

看一下调用情况：

1
2
3
4
5
6
7
8
9
10
public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        String[] fullname = new String[] { "Homer", "Simpson" };
        p.setName(fullname); // 传入fullname数组
        System.out.println(p.getName()); // "Homer Simpson"
        fullname[0] = "Bart"; // fullname数组的第一个元素修改为"Bart"
        System.out.println(p.getName()); // "Bart Simpson"
    }
}

注意到setName()的参数现在是一个数组。一开始，把fullname数组传进去，然后，修改fullname数组的内容，结果发现，实例p的字段p.name也被修改了！

结论：引用类型参数的传递，调用方的变量，和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方（因为指向同一个对象嘛）。

🧠我们再看一个神奇的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        String bob = "Bob";
        p.setName(bob); // 传入bob变量
        System.out.println(p.getName()); // "Bob"
        bob = "Alice"; // bob改名为Alice
        System.out.println(p.getName()); // "Bob"
    }
}
class Person {
    private String name;
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

为啥还是“Bob”呢？字符串不也是引用类型嘛。引用类型的不是应该被改变吗？

🍎解释：

我们知道String类是不可变类，当我们执行以下操作时：

1
2
String bob = "Bob";//1
bob = "Alice"; //2

1处和2处bob所指向的地址是不同的。

那么上面的例子就很好解释了：

  1. 定义字符串时，bob存储了字符串”Bob”在内存中的地址
1
String bob = "Bob" // bob -> "Bob"
  1. 实例化对象p的时候，给p.name传入了bob 存储的地址，即”Bob”在内存中的地址
1
p.setName(bob)  // p.name -> "Bob"
  1. 给bob赋值后，bob指向了内存中新的字符串”Alice”的地址
1
bob = "Alice" // bob -> "Alice"
  1. 此时p.name仍然指向 “Bob”在内存中的地址
1
// p.name -> "Bob"

而当我们传入的是数组时，它的逻辑是：

  1. 定义数组时，由于是String数组，所以fullname[0] 存储的实际上是字符串 “Homer”的地址；同理，fullname[1] 指向 字符串”Simpson” 的地址
1
String[] fullname = new String[] { "Homer", "Simpson" }; // fullname[0] -> "Homer"
  1. 实例化对象p的时候，传入了fullname指向的地址，所以name[0]指向fullname[0]在内存中的地址，而fullname[0] 又指向字符串”Homer”
1
p.setName(fullname); //p.name[0] -> fullname[0] -> "Homer"
  1. 修改fullname[0]时，就是改变 fullname[0] 的指向，修改后为fullname[0]存储的是字符串”Bart”的地址
1
fullname[0] = "Bart" // fullname[0] -> "Bart"
  1. 而此时p.name[0] 的指向并没有变，还是指向fullname[0]所在的地址，访问p.name[0] 时先在内存中找到fullname[0]，又根据fullname[0]中存储的地址信息访问到”Bart”
1
fullname[0] = "Bart" // p.name[0] -> fullname[0] -> "Bart"