在Java中，是否将对象的非原始包含字段传递给作为对象句柄传递的方法，如果是，这如何影响其可变性？

问题描述

如果将对象的非原始包含字段作为引用该字段对象的对象句柄进行传递，那么在原始传递的字段被更新/更改后，是否容易被更改？

public class MutableDog
{
    public String name;
    public String color;

    public MutableDog(String name,String color)
    {
        this.name = name;
        this.color = color;
    }
}

public class ImmutableDog // are fields of these objects truly safe from changing?
{
    private final String name;
    private final String color;

    public ImmutableDog(MutableDog doggy)
    {
        this.name = doggy.name;
        this.color = doggy.color;
    }

    public String getColor()
    {
        return this.color;
    }
}

public static void main(String[] args)
{
    MutableDog aMutableDog = new MutableDog("Courage","Pink");

    ImmutableDog anImmutableDog = new ImmutableDog(aMutableDog);

    aMutableDog.color = "Pink/Black";

    anImmutableDog.getColor().equals(aMutableDog.color); // true or false?
}

从本质上讲，ImmutableDog 真正是不可变的吗？在示例中，使用字符串。使用可变对象（例如Collection）会有所作为吗？

此问题是对this答案的回答。

解决方法

ImmutableDog实际上是不可变的，即使它可以接收来自可变对象的字符串。这是因为String是不可变的。这也证明了不变性的巨大好处之一-您可以传递不变的对象而不必担心它们会突然改变。

您可能会想，通过设置ImmutableDog实例的字段，可以以某种方式更改MutableDog中的字段：

aMutableDog.color = "Pink/Black";

但是，"Pink/Black"是与此处分配给ImmutableDog的字符串实例不同的字符串实例，因此ImmutableDog不会改变。

---

另一方面，如果ImmutableDog具有可变类型的字段，则它不再是真正不变的。

例如，这是您的相同代码，但使用StringBuilder：

public class MutableDog
{
    public StringBuilder name;
    public StringBuilder color;

    public MutableDog(StringBuilder name,StringBuilder color)
    {
        this.name = name;
        this.color = color;
    }
}

public class ImmutableDog // are fields of these objects truly safe from changing?
{
    private final StringBuilder name;
    private final StringBuilder color;

    public ImmutableDog(MutableDog doggy)
    {
        this.name = doggy.name;
        this.color = doggy.color;
    }

    public String getColor()
    {
        return this.color.toString();
    }
}

public static void main(String[] args)
{
    MutableDog aMutableDog = new MutableDog("Courage","Pink");

    ImmutableDog anImmutableDog = new ImmutableDog(aMutableDog);

    aMutableDog.color.append(" and Black");

    anImmutableDog.getColor().equals(aMutableDog.color);
}

现在，不可变的狗的颜色似乎会改变。您仍然可以通过在构造函数中复制字符串生成器来对此进行防御：

public ImmutableDog(MutableDog doggy)
{
    this.name = new StringBuilder(doggy.name);
    this.color = new StringBuilder(doggy.color);
}

但是，这仍然允许您（偶然）修改ImmutableDog类中的字符串生成器。

所以不要在不可变的类中存储可变的类。 ：）

,

这非常简单：java中的任何引用类型最终都会指向某个对象。

如果该对象具有可变状态，则可以使用对该对象的任何引用来更改该状态。

因此，您是正确的：仅在每个字段声明之前放置private final并不一定会使该类本身不可变。

在您的示例中，String类是不可变的（除了使用Unsafe的技巧之外）。分配name和color之后，引用将无法更改，它们指向的对象也无法更改。

但是，当然可以：例如，如果类型为List，则很可能在其他地方更改了基础对象。如果要防止这种情况，则必须例如创建该传入列表的副本，并保留对此的引用。

,

在所有感官和情况下，它真的都是一成不变的吗？ 否。在某种程度上是不变的吗？ 是的。

只要您仅执行变量分配，不可变的狗实际上总是会保持不变。通常，这是由于按值传递语义引起的，here对此进行了详细说明。

在color狗中复制ImmutableDog的引用时，实际上就是复制了句柄。然后，当您通过为可变狗分配Pink/Black值来修改颜色时，可变狗的句柄会更改，但是不可变的狗仍会保留原始句柄，指向原始颜色。

对于String类型，由于字符串是不可变的，因此可以更进一步。因此，保证在字符串上调用任何方法都不会修改原始值。因此，就字符串而言，是的，不可变的狗是真正不可变的并且可以信任。

馆藏确实有所作为。如果我们对您的班级设计稍作更改：

public class MutableDog {
    public String name;
    public List<String> acceptedMeals;

    public MutableDog(String name,List<String> acceptedMeals) {
        this.name = name;
        this.acceptedMeals = new ArrayList<>(acceptedMeals);
    }
}

public class ImmutableDog {
    private final String name;
    private final Iterable<String> acceptedMeals;

    public ImmutableDog(MutableDog doggy) {
        this.name = doggy.name;
        this.acceptedMeals = doggy.acceptedMeals;
    }

    public Iterable<String> getAcceptedMeals() {
        return this.acceptedMeals;
    }
}

并执行以下代码：

public static void main(String[] args) throws IOException {
    MutableDog mutableDog = new MutableDog("Spot",Collections.singletonList("Chicken"));
    ImmutableDog immutableDog = new ImmutableDog(mutableDog);

    immutableDog.getAcceptedMeals().forEach(System.out::println);

    mutableDog.acceptedMeals.add("Pasta");

    immutableDog.getAcceptedMeals().forEach(System.out::println);
}

打印出以下内容：

Chicken
Chicken
Pasta

这是由于ImmutableDog的构造函数将句柄复制到acceptedMeals集合，但是新句柄指向的位置与原始集合相同。因此，当您通过可变狗调用修改时，由于ImmutableDog指向内存中的同一位置，因此其值也可能会被修改。

在这种情况下，您可以通过执行集合的深层副本来避免这种副作用，而不是简单地复制参考句柄：

public ImmutableDog(MutableDog doggy) {
    this.name = doggy.name;
    this.acceptedMeals = new ArrayList<>(doggy.acceptedMeals);
}

这样做，上面介绍的相同方法main仅打印以下内容：

Chicken
Chicken