Question

The Object.clone() method in Java is pretty special, as instead of returning a copy of the object that is to be cloned with the Object type, it returns the correct Object type. This can be better described with the following code:

class A implements Cloneable
{
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class B extends A {
}

public class MainABC {
    public static void main(String[] args) throws CloneNotSupportedException {
        B b = new B();
        B b1 = (B)b.clone(); //see here that we are using A's .clone(). The only
                             //thing it does is call Object's clone().
        System.out.println(b1.getClass()); //but as we see here, its not an Object
                                           //its a B!
    }
}

So, could anyone explain if possible if is there anyway to replicate what happens inside Object.clone()’s method?

Answer 1

It is definitely true that Object.clone() does a few things that simply can not be achieved in Java.

From Josh Bloch on Design: Copy Constructor versus Cloning (emphasis mine):

Object’s clone method is very tricky. It’s based on field copies, and it’s “extra-linguistic.” It creates an object without calling a constructor. There are no guarantees that it preserves the invariants established by the constructors.

Object.clone() does something that isn’t supposed to be allowed by the language. That is why, among many other reasons, clone() is broken.

(If you haven’t already, you should also read his book Effective Java, to understand why he (and many others) think that Java’s clone() and Cloneable is broken).

---

If you just want to create an object of the same class as another arbitrary object, then this is actually quite achievable, with some caveat (namely that not all types are publicly instantiable) by using reflection.

Here’s an example of how to use reflection to:

• Find out the class of an object at run-time
• List its declared fields, methods, and constructors
• Find its copy constructor (if any), and tries to invoke it using the given object as
  parameter.

---

import java.lang.reflect.*;

public class NewInstance {
   static void print(String label, Object[] arr) {
      System.out.println(label);
      for (Object o : arr) {
         System.out.println(o);
      }
      System.out.println("---");
   }

   static Object newInstance(Object o) {
      Class<?> c = o.getClass();
      System.out.println("Class is " + c);
      print("FIELDS:", c.getDeclaredFields());
      print("METHODS:", c.getDeclaredMethods());
      print("CONSTRUCTORS:", c.getDeclaredConstructors());

      try {
         Constructor<?> cc = c.getDeclaredConstructor(c);
         o = cc.newInstance(o);
      } catch (NoSuchMethodException e) {
         System.out.println("No copy constructor found!");
      } catch (IllegalAccessException e) {
         System.out.println("Copy constructor inaccessible!");
      } catch (InstantiationException e) {
         System.out.println("Instantiation failed!");
      } catch (InvocationTargetException e) {
         System.out.println("Copy constructor threw " + e.getCause());
      }
      return o;
   }

   public static void main(String args[]) {
      Object o1 = "hello";
      Object o2 = newInstance(o1);
      boolean success = (o1 != o2) && (o1.equals(o2));
      System.out.println("Attempt " + (success ? "succeeded!" : "failed :("));
   }
}

Output:

Class is class java.lang.String
FIELDS:
// (omitted)
METHODS:
// (omitted)
CONSTRUCTORS:
public java.lang.String()
public java.lang.String(java.lang.String) // this is what we're looking for!
// (rest omitted)
---
Attempt succeeded!

Note that this is just an example to show type can be inspected at run time and a copy constructor can be looked for and invoked. As is, it doesn’t work if o is an ArrayList, because it has no constructor that takes an ArrayList (it does have one that takes a Collection, which an ArrayList is).

I’ll leave it to you as an exercise on how to expand the search for the copy constructor to include these compatible overloads.