Cloning vs. Instanciating a new class

Question

Is cloning good practice in this case? How to do it better?

public ModelCollection startParsing() {

   return parseFeed(new ModelSpecialEntry); 
}

public ModelCollection parseFeed(ModelEntry pattern)  {

   ModelCollection modelCollection = new ModelCollection();

   while( condition ) {

     //TODO: Is cloning the best solution?
     ModelEntry model = (ModelEntry) pattern.clone();



     model.parse();

     //add this item to an collection
     modelCollection.add(model);


   }

   return modelCollection;
}

Answer 1

I thing, that it is like with everything else in programming: it depends on the object specyfication.

Try to make a really quick test: clone 100000 objects and instantiates the same amount of objects and check time how long it takes (System.currentTimeInMilis()). Often clone is faster.

And remember that with clone there is one problem - when adding new field etc. you need to modify clone() method too.

Answer 2

Cloning is rarely a good idea in Java. Try other techniques such as Copy constructors or Factory methods.

Wikipedia has a nice article on why clone() has many disadvantages in Java.

Using copy constructors, create a constructor that takes an instance of the current class as parameter, and copy all fields in the local class:

public class Foo {

    private String bar;
    private String baz;

    public Foo(Foo other) {
        this.bar = other.bar;
        this.baz = other.baz;
    }

}

Using factory methods, create a method that takes your object as parameter and return an object containing the same values:

public Foo copyFoo(Foo other) {
    Foo foo = new Foo();
    foo.setBar(other.getBar());
    foo.setBaz(other.getBaz());
}

Answer 3

You could use a copy constructor instead of implementing Cloneable, but it looks like you have a hierarchy of ModelEntry classes, so using clone may be the best approach. See this question for some pointers on whats wrong with Cloneable

Answer 4

Clone is not a good idea as many programmers agree.

It's error-prone. You have to override clone() carefully.Forgetting invoking super.clone() is a popular bug.