解释评论中提到的问题[重复]

Question

        class Bar{
        int barNum=28;
    }

    class Foo{
        Bar myBar = new Bar();
        void changeIt(Bar myBar){   //Here is object's reference is passed or the object is passed?
            myBar.barNum = 99;
            System.out.println("myBar.barNum in changeIt is " + myBar.barNum);
            myBar = new Bar();  //Is the old myBar object destroyed now and new myBar is referring to something new now?
            myBar.barNum = 420;
            System.out.println("myBar.barNum in changeIt is now "+myBar.barNum);
        }
        public static void main(String args[]){
            Foo f = new Foo();
            System.out.println("f.myBar.barNum is "+f.myBar.barNum);    //Explain f.myBar.barNum!
            f.changeIt(f.myBar);    //f.myBar refers to the object right? but we need to pass reference of the type Bar in changeIt!?
            System.out.println("f.myBar.barNum after changeIt is "+ f.myBar.barNum);    //How do you decide f will call which myBar.barNum?
        }
    }

请解释cmets中提到的问题 代码的输出是 f.myBar.barNum 为 28 myBar.bar 的变化数是 99 myBar.barNum 的变化现在是 420

f.myBar.barNum after changeIt is 99

Answer 1

Java 在方法中传递对对象的引用。如果你愿意，你可以称它为指针。假设您在类 foo 中有对象 myBar 并将其传递给 change it 方法。它不传递对象本身，而是传递对该对象的引用（如果您愿意，可以使用指针）。

当你做 myBar.barNum = 99;这里 myBar 指向类 foo 中的实际对象 myBar 并更改其属性。

当你做 myBar = new Bar();这里的 myBar（我们看到它是一个对象的指针）开始指向一个不同于类 foo 的 myBar 的新 Bar 对象。您将其更改为 400，并且在该对象所在的上下文（方法）中，它是 400。当您离开该方法时，您将返回到原始对象所在的类 foo。由指向 99 的指针更改。

我希望我解释得当。如果一切都不叫 mybar 那就更容易理解了。因为在 myBar=new Bar() 行中，您实际上使用的是本地 mybar （在方法中）而不是全局的。例如：

Bar myBar = new Bar();
    void changeIt(Bar aBar){ 
        aBar.barNum = 99; //Here aBar is a pointer to the myBar above and changes it
        aBar = new Bar();  //Here aBar points to a new myBar instance
        a.barNum = 420; //This will be lost when you leave the method with the new instance created
    }