传递对象给构造函数传递参考

Question

假设我有一个类和构造函数TestClass。

public class TestClass { 
    Foo foo; 

    public TestClass(Foo foo) { 
     this.foo = foo; 
    } 
} 

这里，构造函数接受一个对象，它是Foo类的一个实例。假设我的static void main(String[] args)执行以下操作，与TestClass完全分开;

• （1）实例化foo

• （2）通实例foo到TestClass构造

• （3）变更内部状态的foo

步骤之后（ 3），将foo范围内的我的TestClass的实例的状态有变化吗？

Answer 1

它是不是通过引用。相反，它通过值的参考，这是一个微妙但重要的区别。

你在main()方法的其他变异foo后，foo现场还将展示这些突变，因为你的状态，因为这两个变量指向同一个实例。但是，如果您将foo重新分配给了新内容，foo字段将不会更改。如果foo确实通过引用传递，则这不会成立。总之，所有东西都是通过Java传递的;恰好碰巧通过引用来处理对象，所以这些引用的值被传递。

我会试着用一个例子来说明这一点。考虑下面的类：

class A { 
    public int n; 

    public A(int n) { 
     this.n = n; 
    } 
} 

和下面的方法：

public static void mutate(A a) { 
    a.n = 42; 
} 

现在我们可以有这样的事情：

A a = new A(0); 
A.mutate(a); 

System.out.println(a.n); 

 
42 

我们可以看出，a状态改为mutate()。现在让我们修改静态方法：

public static void mutate(A a) { 
    a = new A(42); 
} 

，然后再试一次：

A a = new A(0); 
A.mutate(a); 

System.out.println(a.n); 

 
0 

正如你所看到的，a的状态不变。如果引用已经传递给函数，我们会期望重新分配的效果在方法范围之外是明显的。尽管如此，一些参考实际上已通过，因为变异引起的变化也会导致方法外的变化。

Answer 2

经过步骤（3）后，我的TestClass实例中的foo是否也有 其状态发生了变化？

是的。

你可能想通过this

更新，以读...

现在，假设你通过构造一个原始值...

public class TestClass { 
    int foo; 

    public TestClass(int foo) { 
     this.foo = foo; 
    } 

    public String toString() { 
     return "TestClass: " + foo; 
    } 
} 

public static void main(String args[]) { 
    int myFoo = 1; 
    TestClass test = new TestClass(myFoo); 
    myFoo += 2; 
    System.out.println("myFoo = " + myFoo); 
    System.out.println("yourFoo = " + test); 
} 

这将输出...

myFoo = 3 
yourFoo = 1 

这证明了改变原语值的事实不会改变构造函数/方法维护的值。

同样的，如果你改变了对象引用之后，你通过它

public class TestClass { 
    Foo foo; 

    public TestClass(Foo foo) { 
     this.foo = foo; 
    } 

    public Foo getFoo() { 
     return foo; 
    } 
} 

public static void main(String args[]) { 
    Foo myFoo = new Foo(); 
    TestClass test = new TestClass(myFoo); 
    myFoo = new Foo(); 
    System.out.println("myFoo == yourFoo = " + myFoo.equals(test.getFoo())); 
} 

将输出

myFoo == yourFoo = false 

由于对象引用是不一样的。

Answer 3

是的，因为您将相同的对象分配给Foo类的另一个引用，即对象相同，但由两个引用引用。