Question

这是一个关于考试的问题。幸运的是，我选择了正确的答案，但我仍然无法理解为什么它是正确的。

考虑这个程序：

class D {
  protected C c;
  public D(C c) {
    this.c = new C(c);
  }
  public C getC() {
    return c;
  }
  public void setC(C c) {
    this.c = c;
  }
}
class C {
  protected String s;
  public C(String s) {
    this.s = s;
  }
  public C(C c) {
    this(c.s);
  }
  public String getS() {
    return s;
  }
  public void setS(String s) {
    this.s = s;
  }

  public static void main(String[] args) {
    C c1 = new C("1");
    C c2 = new C("2");
    D[] d = {
      new D(c1), new D(c1), new D(c2), new D(c2)
    };
    d[0] = d[3];
    c1.setS("3");
    String r = "";
    for (D i: d) {
      r += i.getC().getS();
    }
    System.out.println(r);
  }

}

它会打印2122。我希望2322然而（当你运行代码时，我明显错了）。我的理由背后是：

在main方法的第三行中，初始化了D的四个实例。 D的构造函数创建了C的新实例。 C的一个实例有一个String变量，该变量指向内存中的某个位置。现在，实例变量c，让我们称之为c3，d[1]中的对象有一个实例变量（类型String），让我们来看看称之为s3，指向与String s1变量c1相同的内存。

因此，当我们更改s1时，我预计s3的值也会发生变化，因为它指向内存中的相同位置。

另外，如果您更改D的构造函数，请参阅下文，您将获得2322。我期待的是，现在c3中的变量d[1]直接指向c1的内存位置。

public D(C c) {
  this.c = c;
}

到目前为止我对解释的看法（可能是错误的）：

初始化实例变量s1 / s3时，会生成新的String个对象（到目前为止，我认为它们指向"1"中的String池，因为C的构造函数使它看起来那样）
更改s1时，它的指针将重定向到"3"池中的String。而不是"1"在池中成为"3"。

有人可以解释这种行为吗？我（错误）推理中的错误是什么？

Answer 1

这与String合并无关。主要答案：Is Java "pass-by-reference" or "pass-by-value"?

这是因为D根据C创建了C#c的新实例。这意味着D#c的实例与构造函数C中传递的参数D不同，因此修改该实例不会影响D#c中的当前实例。

用好的方式解释所有这些。

以下是您正在测试的内容：

class Surprise {
    String item;
    public Surprise(String item) {
        this.item = item;
    }
    //this is called copy constructor
    //because you receive an object from the same class
    //and copy the values of the fields into the current instance
    //this way you can have a "copy" of the object sent as parameter
    //and these two object references are not tied by any mean
    public Surprise(Surprise another) {
        //here you just copy the value of the object reference of another#item
        //into this#item
        this.item = another.item;
    }
}

class Box {
    Surprise surprise;
    public Box(Surprise surprise) {
        //here you create a totally new instance of Surprise
        //that is not tied to the parameter surprise by any mean
        this.surprise = new Surprise(surprise);
    }

    public static void main(String[] args) {
        Surprise surprise1 = new Surprise("1");
        Surprise surprise2 = new Surprise("2");
        Box[] boxes = {
            new Box(surprise1),
            new Box(surprise1),
            new Box(surprise2),
            new Box(surprise2)
        };
        boxes[0] = boxes[3];
        //you update surprise1 state
        //but the state of Box#surprise in the boxes that used surprise1
        //won't get affected because it is not the same object reference
        surprise1.item = "3";
        //print everything...
        System.out.println("Boxes full of surprises");
        //this code does the same as the printing above
        for (Box box : boxes) {
            System.out.print(box.surprise.item);
        }
        System.out.println();
    }
}

为什么我的变量包含＆＃34; 2122＆＃34;而不是＆＃34; 2322＆＃34;？

1 个答案: