Question

我有一个对象，其成员类型为“Object”：

class MyObject{
    Object member;

    public Object getObject(){
        return member;
     }

     public void setObject(Object obj){
         member = obj;
     }
}

是否可以深层复制MyObject？

Answer 1

在目前的实施中，这是不可能的，因为member可以是任何东西，你不能复制你不知道的东西。

Answer 2

实施Cloneable标记界面，您可以通过克隆来复制MyObject。

class MyObject implements Cloneable {
    public Object clone(){
      try {
        return super.clone();
      } catch (CloneNotSupportedException e) {
           return null; 
      }
   }
}

成员还需要Cloneable其他方面才能抛出CloneNotSupportedException。 ...

MyObject obj = new MyObject();
MyObject obj1 = obj.clone();

Answer 3

即使它是一个bean，因此也不是一成不变的，我有另一种选择：freeze/thaw pattern。

如果您为对象实现它（这需要您使用构建器类），那么您可以这样做：

final MyObject copy = orig.thaw().freeze();

我发现它比Cloneable甚至构建者（这是一个可逆的构建器）更方便，并且使用了这种模式。

作为奖励，你可以让你的对象不是一个bean，因此是不可变的。我个人非常不喜欢豆类，这就是为什么我想出来......

这种模式也是递归的。我们假设您有Out和In类，其中In是Out的成员。让我们说In服从冻结/解冻。您的Out代码将变为：

public final class Out
    implements Frozen<Builder>
{
    private final In in;

    private Out(final Builder builder)
    {
        in = builder.in.freeze();
    }

    public static newBuilder()
    {
        return new Builder();
    }

    public In getIn()
    {
        return in;
    }

    @Override
    public Builder thaw()
    {
        return new Builder(this);
    }

    public static final class Builder
        implements Thawed<Out>
    {
        private In.Builder in;

        private Builder()
        {
        }

        private Builder(final Out out)
        {
            in = out.in.thaw();
        }

        public Builder setIn(final In in)
        {
            this.in = in.thaw();
        }

        @Override
        public Out freeze()
        {
            return new Out(this);
        }
    }
}

最终结果是，调用copy = orig.thaw().frezze()会返回相同副本，其中新实例为in。

深拷贝“对象”类型

3 个答案: