0

假设我有这个 Java 代码（中期审查！）：

public class A {
public int key;
}

public class B extends A {
}

public class Problem1 {
public static void f(A x) {
A y = x;
y.key = x.key + 1;
}

public static void f(B x) {
B y = new B();
y.key = x.key + 2;
x = y;
}

public static void main(String[] args) {
A p = new A();
p.key = 3;
B q = new B();
q.key = 10;
f(p);
f(q);
p = q;
f(p);
System.out.println(p.key);
}
}

我不确定我是否正确理解 p = q。到目前为止，这是我的理解：因为 B 扩展了 A，所以允许此操作，但它不会使 p 和 q 指向同一个对象。相反，它更新了 p 的键值，但它仍然属于 A 类。这就是为什么 f(p) 最后返回 11 的原因。这与我之前认为我对 Java 的了解不相符，因此将不胜感激。

例如，如果我有 int a = 4 和 int b = 3，那么我会：

a = b;
b++;
return a;

a 将返回 3，即使它应该指向 b 指向的同一事物？

请指教。

4

3 回答 3

1

想想看。Java 原语将实际值保存在内存字节区域中：因此，如果a = 4和b = 3，则 8 字节机器内存区域可以像（二进制）一样保存它

a = 0 0 0 0 0 0 1 1 
b = 0 0 0 0 0 0 1 0

现在，当你说a=b;意味着

a = 0 0 0 0 0 0 1 0 
b = 0 0 0 0 0 0 1 0

然后b++ (i.e. b = b+1)

a = 0 0 0 0 0 0 1 0 
b = 0 0 0 0 0 0 1 1

然后

return a;

Then  a = 0 0 0 0 0 0 1 0 (i.e. 3)

希望你能理解它的原始价值。尽管对于 java 中的对象，这是完全不同的情况。

现在想想，a 和 b 不是原始的，而是具有 int 字段的对象。Sample 类可能看起来像

class Test {
private int value;

public Test(int value){
 this.value = value;
}

public int getValue(){
return value;
}

public int increment(){
value++;
}
}

然后a = new Test(4); and b = new Test(3);在内存中表示如下：

堆：

a = x63489DF8 ---> [Test(4) Object, value = 4, Heap Memory address = x63489DF8]
b = xDFA78945 ---> [Test(3) Object, value = 3, Heap Memory address = xDFA78945]

（a并b持有指向对象的堆内存地址）

现在，当你说a=b;意味着

a = xDFA78945 ---> [Test(3) Object value = 3, Heap Memory address = xDFA78945]
b = xDFA78945 ---> [Test(3) Object value = 3, Heap Memory address = xDFA78945]

（内存地址中的对象x63489DF8是可垃圾回收的，a, b并且指的是同一个对象）

现在，说 b.increment();然后内存区域中的对象xDFA78945被操作并且新对象变为[Test(3) Object value = 4, Heap Memory address = xDFA78945].

a = xDFA78945 ---> [Test(3) Object value = 4, Heap Memory address = xDFA78945]
b = xDFA78945 ---> [Test(3) Object value = 4, Heap Memory address = xDFA78945]

（请注意，更改反映了两个引用，因为两者实际上都指向同一个对象）

现在返回a.getValue()返回 4。（即通过引用完成的更改也b反映在引用a中）

于 2013-10-08T03:58:33.360 回答
0

所有变量都是位持有者。好的

因此，如果它是原始类型，它将持有代表原始的位 lavel 表示的位。

a = b; b++; return a;

这里“3”的位表示被分配给“a”所以它现在是3。但 b 仍然持有代表“3”的位，因此 b 中的 cange 将只保留“b”

现在如果 a 是一个类变量并且 b 也是，在 java 中变量总是持有位。当它是类变量时，它保存代表到达位于堆上的类对象的路径的位。因此，当您这样做时，a = b;a 还将保留到达堆上对象的路径。所以“a”和“b”都持有同一个对象的路径。

如果您更改“a”的属性（更改由var“a”持有的路径到达的对象的属性）。将反映在 b 中。因为这些都指向同一个变量。 在此处输入图像描述

于 2013-10-08T04:39:27.743 回答
0

例如，如果我有 int a = 4 和 int b = 3，那么我会：

a = b;
b++;
return a;

a 将返回 3，即使它应该指向 b 指向的同一事物？

原语按您期望的方式处理。换句话说，a 将给出值 3，因为它占用了 b 的数字或位值。但是，您应该研究autoboxing和immutability。

我不确定我是否正确理解 p = q。到目前为止，这是我的理解：因为 B 扩展了 A，所以允许此操作，但它不会使 p 和 q 指向同一个对象。相反，它更新了 p 的键值，但它仍然属于 A 类。

对于对象，该操作p = q实际上确实将 p 赋值为“引用”（参见底部的链接）到与 q 相同的对象。这就是为什么需要像防御性复制这样的方法。

这也解释了为什么尽管 Java 通过重载方法传递值，但仍会发生修改。f参数x保持原样，一旦进程离开方法范围就会消失，但可以修改引用对象的状态。

这是一个关于 C 指针和 Java 引用之间差异的问题。

https://softwareengineering.stackexchange.com/questions/141834/how-is-a-java-reference-different-from-ac-pointer

于 2013-10-08T04:12:59.000 回答