按引用调用或按值调用

Question

谁能解释一下这个程序是如何执行的？

这是我似乎无法理解其输出的代码：

    class Box {
        int size;
        Box (int s) {
           size = s;
        }
    }
    public class Laser {
        public static void main(String[] args) {
            Box b1 = new Box(5);
            Box[] ba = go(b1, new Box(6));
            ba[0] = b1;
            for(Box b : ba)
                System.out.println(b.size + " ");
        }

        static Box[] go (Box b1, Box b2) {
            b1.size = 4;
            Box[] ma = {b2, b1};
            return ma;
        }
    }

我运行时的实际输出是 4, 4。但根据我的理解应该是 5, 4。 任何人都可以帮助了解这是如何执行的吗？

Answer 1

在 Java 中，对象通过引用传递，基元通过值传递。

public class Laser {
    public static void main(String[] args) {
        //Create a Box of size 5.
        Box b1 = new Box(5);
        //Create an array of Box objects, which are the results of the go method
        Box[] ba = go(b1, new Box(6));
        // ba now looks like {new Box(6), b1 /*b1 is size 4 now*/}
        // assign reference to b1 at index 0 in ba.
        ba[0] = b1;
        // array now looks like {b1, b1}
        for(Box b : ba)
            System.out.println(b.size + " ");
    }

    static Box[] go (Box b1, Box b2) {
        //set the size of the first box to 4
        b1.size = 4;
        //create an array of boxes, with b2 in index 0 and b1 in index 1
        Box[] ma = {b2, b1};
        return ma;
    }
}

Answer 2

当您将对象作为参数传递时，您实际上是在传递对它的一个引用的副本。也就是说，如果您在方法内部修改参数对象，则该对象将在该方法返回时保留这些修改，这就是为什么您看到 b1 在 go 返回后保留了 size = 4 赋值。

Answer 3

Java 总是在方法调用中传递对对象的引用。当您调用 go 时，第一个参数 (b1) 是对您在 main 中的相同 b1 Box 的引用。然后修改该对象，其size 现在是4。

Answer 4

我已经为你添加了 cmets；

The important TWIST that you missed here is;

Box[] ma = {b2, b1}; 不是{b1,b2}。返回时交换内存位置。

       public static void main(String[] args) {
            Box b1 = new Box(5);                 // b1 == location A
            Box[] ba = go(b1, new Box(6));       // ba == location B which stores Location A, D

           // PLEASE NOTE HERE
           // After the function go() is executed;
           // ba[] will have {D, A}
           // So ba[0] will have object b1 which is at location A. 

            ba[0] = b1;                          // location B will now store A and A
            for(Box b : ba)
                System.out.println(b.size + " ");  //  Output: 4 and 4
        } 

        static Box[] go (Box b1, Box b2) {        // go(location A, location D )
            b1.size = 4;                          // A's object.size = 4
            Box[] ma = {b2, b1};                  // position is interchanged here (D and A)
            return ma;                            // return the location of ma
        }

希望这会有所帮助。

如果您有任何问题，请告诉我。在java中，一切都是按值传递的。内存地址按值传递。

Answer 5

传递给go 的值是对象的引用。如果您来自 C，您可以将参数视为具有指针类型，类似于

Box** go (Box *b1, Box *b2) {
     b1->size = 4;
     /* allocate an array of Box*, set it up, return it */
}

（对不起，如果我把 C 语法弄错了。）指针（引用）本身是按值传递的，这意味着如果你在“go”（在 C 程序中）说：

b1 = &some_other_box;

它不会影响调用端的任何变量，并且它在 Java 中的工作方式相同。这使它与 PHP 或 Pascal 中的 var 参数有点不同。

Answer 6

Java 在方法调用中将引用的副本传递给对象。

你不能通过赋值来改变一个对象。

public static void main(String[] args) {
    Box b1 = new Box(5);
    Change(b1);
    System.out.println(b1.size + " ");

static void Change(Box b1) {
    b1 = new Box(6);
}

这将始终返回 5，因为函数 Change 只会将副本覆盖到引用的对象。

但是，您可以像这样影响对象的属性：

public static void main(String[] args) {
    Box b1 = new Box(5);
    Change(b1);
    System.out.println(b1.size + " ");

static void Change(Box b1) {
    b1.size = 6;
}

这将返回 6（对对象的引用保持不变）。

Answer 7

如果原帖中的函数 'go' 在 C 中（并且 b1 和 b2 是 C 指针），它可以做以下两件事（调用者会看到）：

1. 更改 b1 和 b2 指向的数据结构中的变量值。
2. 让原来的 b1 和 b2 指向不同的数据结构。

在 Java 中，我们可以做 1，但不能做 2，因为 go 无法访问原始的 b1 和 b2。 （它可以访问 b1 和 b2 的副本。在子程序开始时，副本 b1 指向与原始 b1 相同的对象，依此类推。）

说Java是通过调用传递确实错过了一些东西，即函数做1的能力，即改变b1和b2引用的堆中对象的属性。 [这就是语句中发生的事情，b1.size = 4;，导致原发帖者的困惑。]

'go' 中的 b1 与 'main' 中的 b1 位置不同。但是，当函数启动时，'go' 中的 b1 引用与 'main' 中的 b1 相同的对象，并且当使用 'main' 中的 b1 作为引用时，将看到使用 'go' 中的 b1 对对象所做的任何更改。

但是，如果 'go' 中的 b1 设置为另一个 Box，则 'main' 中的 b1 不会看到这个；它仍然会看到以前的 Box。