关于“传地址”和“回收”的问题：

Question

我的理解是这样：
1》v =  vh以后，anther中的v和vh是指向同一个对象，而ObParm 中的v单独指向一个对象。
2>都回收，否则就发生了内存泄露了。
因为 在public void another(ValHold v) 的开始有 v.i = 20;
而函数的参数是引用传递，因此呢？输出结果会是
10b
20a

Answer 1

anther中的vh在被回收后，anther中的v指向哪里呢？

Answer 2

同意  study_body(珍惜每一天)其实很简单，如果确实看不出来，只要自己动笔画一画图就行了。

Answer 3

class ValHold {
        public int i = 10;
}
public class ObParm {
    public void amethod() {
        ValHold v = new ValHold();
        another(v);
        System.out.println(v.i + "a"); //(*)
                          //    ~~~~~~加上一个标识 a
    }    public void another(ValHold v) {
        //如果是这样，anther中的v是否会被回收呢？
        v.i = 20;
        System.out.println(v.i + "b");
                           //   ~~~~~~加上一个标识 b
    }    public static void main(String[] argv) {
        ObParm o = new ObParm();
        o.amethod();
    }
} 如果是这样，anther中的v是否会被回收呢？

Answer 4

对照C++的传指针问题就知道了，
amethod(A* a)
{
}
如果在此方法中改变参数a的地址，返回后传进去的参数地址是不变的。也就是说在函数体内改变的应该是指针所指地址的内容，而不能改变地址本身。

Answer 5

1)、
v = vh;之后，another中的v和vh指向同一个对象
而amethod里的v指向另外一个对象2)、
关于回收问题，在java里，你是不需要考虑这个问题的
这个对象会不会被回收，何时被回收都是不确定的
因为在java中对象的回收是不是程序员去做的事情
而是由垃圾回收器gc来负责，当系统认为有进行垃圾回收的必要时
它会自动启动垃圾回收器
因此，你不可能知道何时垃圾回收器启动但是你不必担心内存泄漏问题如果你想知道的更详细，建议去看一下Think in java 2nd Edition
在第四章初始化与清除里，这个问题稍有涉及，我觉得讲得比较易懂^_^

Answer 6

1.在anther中，v=vh以后，ObParm中的v是ObParm中的v.和下面两个不同.
anther中的v作为ObParm中v的引用,但是现在已经是vh的引用了,所以和vh指向同一个对象.  2.anther中的v在anther结束以后，它应该继续指向ObParm中的v,所以它刚才指的对象也就是vh应该会被回收.

Answer 7

楼上的第1点意思是对的，表达是错的。“anther中的v作为ObParm中v的引用,但是现在已经是vh的引用了”，应该是anther中的v作为ObParm中v指向对象的引用,但是现在已经是vh指向对象的引用。
楼上2 就不对了。 another（）执行完毕，局部变量v，vh都不存在了，
没有任何引用指向ValHold vh = new ValHold(); 所建立的对象，这个对象符合回收的条件，何时回收不确定。

Answer 8

楼主 没搞清楚object和object reference的关系。
比如楼主问anther中的v在anther结束以后，是否被回收？ 和anther中的vh在被回收后，anther中的v指向哪里呢？ 这样提问是不妥的，其实被回收的是object不是object reference。 偶下面把这个程序给楼主解释一下：
    ValHold v = new ValHold();  建立了一个object（暂且叫作ValHoldA）和指向这个object的引用v（暂且叫作amethod.v）。显然ValHoldA是一个object，amethod.v是一个object reference（可以简单理解为对象的地址而不是对象本身），他们是不同的，又是有联系的。  object reference        object
                        __________
                       | ValHoldA |
                       |----------|
     amethod.v ------->| i = 10   |  ValHold v = new ValHold();
                       |__________|      another(v); 调用了方法another()，传入的参数是amethod.v的一个copy实际上是建立了一个新的object reference，并且也指向ValHoldA。注意由于java在传递参数时，使用的是reference而不是object本身，此时并没有新的object的copy产生。
                        __________
                       | ValHoldA |
     amethod.v ------->|----------|  another(v);
     another.v ------->| i = 10   |  
                       |__________|      v.i = 20; 修改了对象ValHoldA的变量i为20，并未改变引用与对象之间的关系 如下：
                        __________
                       | ValHoldA |
     amethod.v ------->|----------|  v.i = 20;
     another.v ------->| i = 20   |
                       |__________|      ValHold vh = new ValHold(); 建立了一个新的object（暂且叫作ValHoldB）和指向这个object的引用vh。 于是就有了两个ValHold object和三个分别指向它们的object reference。 如下：
                        __________
                       | ValHoldA |
     amethod.v ------->|----------| 
     another.v ------->| i = 20   |
                       |__________|  
                        __________
                       | ValHoldB |
                       |----------|  ValHold vh = new ValHold();
     another.vh------->| i = 10   |
                       |__________|  
v =  vh; 这是object reference之间的赋值，不是object之间的赋值。改变了引用与对象之间的关系，如下：
                        __________
                       | ValHoldA |
                       |----------|
     amethod.v ------->| i = 20   |
                       |__________|  
                        __________
                       | ValHoldB |
     another.v ------->|----------|  v =  vh;
     another.vh------->| i = 10   |
                       |__________| 
如此，两个println的输出结果就显而易见了。
你的第一个问题，它们并不指向同一个对象，而是两个对象。
你的第二个问题，虽然你的提问方式是错的。 答案还是有的，another（）执行结束后，another.v和another.vh都不存在了， 于是，ValHoldB就不存在指向它的引用，因而，符合回收的条件，何时回收不确定。你不能强迫GC在某个特定时间回收某个符合回收条件的对象，只能建议。

Answer 9

  这是个传值的题。
  bloodmelon(背后的空间) 说得很清楚。