Calling A Super Method Externally

Question

Hi,
I would like to call an overridden method, a super method, of an object externally. I thought all I needed to do was:
1. get the java.lang.Class object of the super class where the original method was declared and implemented.
2. get the appropriate java.lang.reflect.Method object from the Class object.
3. override the java language protections on the Method object.
4. Call Method.invoke() with the instance of the subclass which I wanted to call the method on.
Unfortunately, when I got to step 4, I saw this in the documentation for Method.invoke:
"If the underlying method is an instance method, it is invoked using dynamic method lookup as documented in The Java Language Specification, Second Edition, section 15.12.4.4; in particular, overriding based on the runtime type of the target object will occur."
Is there any way to externally access the functionality of a super method implementation on a subclass that overrides it? It seems like there should be...
In case you are wondering, the reason I am doing this is I am trying to implement a deep clone method. However, I would like any class to be able to call the deep clone method by passing themselves as an argument to a static method -- that way you don't have to worry about subclasses inheritting clone or anything like that. The code would look something like this (however it seems that according to the docs, this would result in an infinite recursion because when the Object.clone() method is invoked, it would actually resolve to the MyDeepCloneableObject.clone() method (which would call the utility function, which would invoke the Object.clone() again etc. etc.)):
public class MyDeepCloneableObject implements Cloneable {
public Object clone() {
return ObjectUtil.deepClone(this);
public class ObjectUtil {
private static final Method OBJECT_CLONE_METHOD;
private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
private static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
static {
//Set the OBJECT_CLONE_METHOD
try {
OBJECT_CLONE_METHOD =
Object.class.getDeclaredMethod("clone", EMPTY_CLASS_ARRAY);
OBJECT_CLONE_METHOD.setAccessible(true);
} catch (NoSuchMethodException e) {
System.out.println(e.toString());
e.printStackTrace();
} catch (RuntimeException e) {
System.out.println(e.toString());
e.printStackTrace();
public static Object deepClone(Cloneable object, int levels) {
Object clone;
try {
clone = OBJECT_CLONE_METHOD.invoke(object, EMPTY_OBJECT_ARRAY);
} catch (IllegalAccessException e) {
System.out.println(e.toString());
e.printStackTrace();
return null;
} catch (InvocationTargetException e) {
System.out.println(e.toString());
e.printStackTrace();
return null;
} catch (RuntimeException e) {
System.out.println(e.toString());
e.printStackTrace();
return null;
// Use more reflection on fields of clone to implement deep clone
}

Answer 1

In your example the clone method is not creating a clone, just returning a new instance of an object of the same type. In both cases the default shallow clone method should be implemented as follows:
public Object clone() {
//Call Object.clone()
return super.clone;
By doing so, any subclasses will also have their fields copied when clone() is called.
From the javadocs for Object.clone():
"The method clone for class Object performs a specific cloning operation. First, if the class of this object does not implement the interface Cloneable, then a CloneNotSupportedException is thrown. Note that all arrays are considered to implement the interface Cloneable. Otherwise, this method creates a new instance of the class of this object and initializes all its fields with exactly the contents of the corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation."
Now as to how the parent is supposed to know about fields in subclasses, the implementation of clone is implemented in a native method in Object, so the JVM can pretty much know anything about the subobject as long as it has a reference to it. Further, if I wanted to make my own implementation, I could using reflection:
public Object clone() {
// Get the runtime class of this object, note that the runtime class
// may be a subclass of the class in which this clone method is defined
Class objectClass = this.getClass();
//Get all of the fields in this class and it's super classes
List fieldsList = new ArrayList();
while (objectClass != null) {
Field[] fields = objectClass.getDeclaredFields();
for (int j =0; j < fields.length; j++) {
fieldsList.add(fields[j]);
objectClass = objectClass.getSuperClass();
//Now I can create a new instance of the runtime class and set
//all of its fields appropriately
However, I'm sure the JVM's implementation is far more efficient.
I have not benchmarked serialization. However, all the steps in my procedure would have to be done for serialization anyway (i.e. get list of all fields, instantiate equivalent field values and set them in the new object), but serialization also needs to convert everything to a byte representation and then parse it out again. Furthermore, serialization will perform a fully deep clone, where as I only want a one level deep clone (or two depending on how you think of it -- i.e. not a shallow copy of references (as Object.clone(0 does), but a copy of direct fields and containers (i.e. Maps and Collections in fields should be cloned, but not objects in the Maps and Collections). So if an object has a field which is a List and the List field contains 1 entry, and the object is cloned, then subsequent modifications to the List field in the cloned object are not reflected in the original object's List field and vice versa (i.e. the 1 entry is removed in the original , but remains in the clone's version of the List field).