0

这是考试中的一道题。幸运的是我选择了正确的答案，但我仍然不明白为什么它是正确的。

考虑这个程序：

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初始化了四个 get 实例。的构造函数D创建 的新实例C。的实例C有一个String变量，该变量指向内存中的某个点。现在对象的实例变量c，我们称之为它c3，d[1]有一个实例变量（类型String），我们称之为它，指向与 的变量s3相同的内存。String s1c1

所以当我们改变时s1，我希望 的值s3也会改变，因为它指向内存中的同一个点。

附带说明一下，如果您更改 的构造函数D，请参见下文，您将得到2322相反的结果。这是我所期望的，因为现在变量c3ind[1]直接指向c1.

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

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

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

谁能解释这种行为？我的（错误的）推理中有什么错误？

4

1 回答 1

2

这根本与String池化无关。主要答案：Java 是“按引用传递”还是“按值传递”？

那是因为D创建了一个C基于的新实例C#c。这意味着 的实例与构造函数中传递的D#c参数不同，因此修改该实例不会影响 中的当前实例。CDD#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();
    }
}
于 2014-08-19T17:32:44.817 回答