Deep copy "Object" type

Question

I have an object with a member of type "Object":

class MyObject{
    Object member;

    public Object getObject(){
        return member;
     }

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

Is it possible to deep copy MyObject?

You cannot guarantee deep copy here since Object could be anything. For example, a serialization technique here would fail if not all of the Object members implement Serializable. — Ravi K Thapliyal, Jun 11 '13 at 06:43

score 10 · Accepted Answer · answered Jun 11 '13 at 06:38

10

In its current implementation it is impossible because member can be anything and you cannot make a copy of what you dont know.

answered Jun 11 '13 at 06:38

Evgeniy Dorofeev

133,369
30
199
275

1

+1 There is no way to guarantee that an object is copyable at all, deep or shallow, until runtime when its only guaranteed interface is Object. – Joachim Isaksson Jun 11 '13 at 06:45
I think it's possible by using `reflection`. – Rong Nguyen Jun 11 '13 at 06:52
2

@RongNK You can copy some objects using reflection (with fairly horrible performance), but not all. Database/network connections and open files come to mind. – Joachim Isaksson Jun 11 '13 at 06:56

Subhrajyoti Majumder · Answer 2 · 2013-06-11T06:59:21.497

3

Implement Cloneable marker interface and you can copy of MyObject by clonning.

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

Members also need to be Cloneable other wise it will throw CloneNotSupportedException. ...

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

edited Jun 11 '13 at 06:59

answered Jun 11 '13 at 06:33

Subhrajyoti Majumder

40,646
13
77
103

That is `Cloneable` ;) – fge Jun 11 '13 at 06:34
1

+1 too quick and sharp :) – Suresh Atta Jun 11 '13 at 06:35
What if `member` is not `Cloneable`? – Bhesh Gurung Jun 11 '13 at 06:35
Um... does clone() really deep copy, I thought it unless overridden just made a field by field copy...? – Joachim Isaksson Jun 11 '13 at 06:36
@BheshGurung member need to be also clonnable – Subhrajyoti Majumder Jun 11 '13 at 06:38
2

Obligatory: http://stackoverflow.com/a/4081895/697449 – Paul Bellora Jun 11 '13 at 06:39
Implementing Cloneable doesn't help, if I set new member-object of obj, member of obj1 will be changed as well. – yuris Jun 11 '13 at 06:44
@yuris Yes, it does not deep copy, just shallow copy. – Joachim Isaksson Jun 11 '13 at 06:46
@Joachim Isaksson, yes, I asked how to make a deep copy. – yuris Jun 11 '13 at 06:50
@yuris Then this answer is not your answer. – Joachim Isaksson Jun 11 '13 at 06:53

fge · Answer 3 · 2013-06-11T06:53:59.337

Even though it is a bean, therefore not immutable, I have an alternative: the freeze/thaw pattern.

If you implement it for your object (which would require that you use a builder class) you could then do:

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

I find it much more convenient than Cloneable or even builders (this is a reversible builder) and use that pattern a lot.

As a bonus, you could make your object NOT being a bean and therefore being immutable. I have a personal profound dislike of beans which is why I came up with that...

And this pattern is recursive too. Let us suppose that you have classes Out and In where In is a member of Out. Let us say that In obeys freeze/thaw. Your code for Out then becomes:

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);
        }
    }
}

The net result is that calling copy = orig.thaw().frezze() returns an identical copy with a new instance of in.

Deep copy "Object" type

3 Answers3