Java中的new关键字和引用传参

先看看Java中如何使用new关键字创建一个对象的。

[java] view plain copy

1. public class Student {  
2.     public String name;  
3.     public int id;  
4.     public static void main(String[] args) {  
5.         Student s = new Student();//看这句话  
6.     }  
7. }  

语句Student s = new Student();可以拆成两句话：

语句1:Student s;在 栈 中创建一块空间，该空间的名字是s，变量s类型是Student指针类型看，值为空(不是null)。

语句2:s = new Student();首先在 堆 中创建一块空间，该空间存储的是Student类对象的成员变量;然后用s指向这块内存。

这两句话对应的内存变化如下图：

所以s中存储的s所指向的对象在堆内存中地址。

理解了new关键字创建对象的过程，再来看看引用传参。Java中的引用一共有三种，数组、类对象、接口，下面着重看看数组和类对象的传参过程。

[java] view plain copy

1. public class Test {  
2.     public static void main(String args[]){  
3.         int a[] = new int[3];  
4.         a[0] = 1;  
5.         a[1] = 2;  
6.         a[2] = 3;  
7.         int b[] = new int[3];  
8.         b[0] = 4;  
9.         b[1] = 5;  
10.         b[2] = 6;  
11.         b = a;  
12.         b[0] = 7;  
13.         b[1] = 8;  
14.         b[2] = 9;  
15.         System.out.println(a[0]+" "+a[1]+" "+a[2]);  
16.     }  
17. }  

语句 b =a; 之前的内存如图所示：

b = a执行之后，a的值(即第一个数组的首地址)被赋给b，则b也指向了第一个数组，内存如下图：

[java] view plain copy

1. b[0] = 7;  
2. b[1] = 8;  
3. b[2] = 9;  

这三条语句修改了第一个数组中的值，内存如下:

输出结果如下：

下面来看类对象的情况(跟数组是类似的)

例2：

[java] view plain copy

1. public class Student {  
2.     public String name;  
3.     public int id;  
4.     public Student(String name,int id){  
5.         this.name = name;  
6.         this.id = id;  
7.     }  
8.     public static void main(String[] args) {  
9.         Student s1 = new Student("Tom",18);  
10.         Student s2 = new Student("Sally",19);  
11.         s2 = s1;  
12.         s2.name = "Mark";  
13.         s2.id = 20;  
14.         System.out.println(s1.name+" "+s2.id);  
15.     }  
16. }  

语句s2 = s1;执行之前的内存状态如下图:

s2 = s1执行之后，内存状态改变为:

[java] view plain copy

1. s2.name = "Mark";  
2. s2.id = 20;  

这两句话，修改了s1指向的对象的值，如下图:

输出结果如下:

最后看一下，s2原来指向的那块内存，现在没有引用指向它了，所以这块内存以及里面存的值都不能用了，Java存在"垃圾回收"机制，会定时清理没有引用指向的内存，所以这块内存会被回收，这与C++不同，在C++中，需要手动delete删除一个用new关键字创建的对象。