Access to private inherited fields via reflection in Java

Question

I found a way to get inherited members via class.getDeclaredFields(); and acces to private members via class.getFields() But i'm looking for private inherited fields. How can i achieve this?

• Benoit Courtine: "private inherited fields" does not exist. If a field is private, it is not inherited, and remains only to the scope of the parent class. To access parent private fields, you have to access parent class first (cf. aioobe's response)
• Bozho: that said, protected fields are inherited, but you have to do the same to get them by reflection.
• Vadzim: Possible duplicate of Retrieving the inherited attribute names/values using Java Reflection

Answer 1

This should demonstrate how to solve it:

import java.lang.reflect.Field;
class Super {
 private int i = 5;
}
public class B extends Super {
 public static void main(String[] args) throws Exception {
 B b = new B();
 Field f = b.getClass().getSuperclass().getDeclaredField("i");
 f.setAccessible(true);
 System.out.println(f.get(b));
 }
}

(Or Class.getDeclaredFields for an array of all fields.)

Output:

5

• NeoZoom.lua: Does this get all superclasses' fields or just the direct superclass?
• aioobe: Direct super classes' fields. You can recurse on getSuperclass() until you reach null if you want to go higher.
• Holger: Why don't you use getDeclaredFields()[0] or getDeclaredField("i") but rather repeat the [0] array access in the next two statements?
• aioobe: It's due to the way this particular question is formulated. It was basically just a demonstration of how to use getDeclaredFields. Answer has been updated.

Answer 2

The best approach here is using the Visitor Pattern do find all fields in the class and all super classes and execute a callback action on them.

---

Implementation

Spring has a nice Utility class ReflectionUtils that does just that: it defines a method to loop over all fields of all super classes with a callback: ReflectionUtils.doWithFields()

Documentation:

Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.

Parameters:
- clazz - the target class to analyze
- fc - the callback to invoke for each field
- ff - the filter that determines the fields to apply the callback to

Sample code:

ReflectionUtils.doWithFields(RoleUnresolvedList.class,
 new FieldCallback(){
 @Override
 public void doWith(final Field field) throws IllegalArgumentException,
 IllegalAccessException{
 System.out.println("Found field " + field + " in type "
 + field.getDeclaringClass());
 }
 },
 new FieldFilter(){
 @Override
 public boolean matches(final Field field){
 final int modifiers = field.getModifiers();
 // no static fields please
 return !Modifier.isStatic(modifiers);
 }
 });

Output:

Found field private transient boolean javax.management.relation.RoleUnresolvedList.typeSafe in type class javax.management.relation.RoleUnresolvedList
Found field private transient boolean javax.management.relation.RoleUnresolvedList.tainted in type class javax.management.relation.RoleUnresolvedList
Found field private transient java.lang.Object[] java.util.ArrayList.elementData in type class java.util.ArrayList
Found field private int java.util.ArrayList.size in type class java.util.ArrayList
Found field protected transient int java.util.AbstractList.modCount in type class java.util.AbstractList

• thinlizzy: that is not a "visitor pattern", but it is still a very nice tool if you have the Spring virus in your code. thanks for sharing it :)
• Sean Patrick Floyd: @jose.diego I'm pretty sure you could argue about that. It visits a class hierarchy rather than an object tree, but the principle remains the same
• gene b.: Not sure if this comment will get a response, but you're only visiting a particular field at a time with this solution. If I need to look at other fields at the same time -- e.g., set this field to "abc" if another field is NULL -- I don't have the object as a whole available to me.
• spaceman spiff: Its too bad that the JavaDoc for this class indicates that "it is only intended for internal use", so this is a possible risk to anyone who wishes to use it.
• Sean Patrick Floyd: @spacemanspiff you're technically correct, but this class has been around for about 15 years (including 4 major release versions) and has widely been used by many Spring customers. I doubt they'll pull it back now.

Answer 3

This'll do it:

private List<Field> getInheritedPrivateFields(Class<?> type) {
 List<Field> result = new ArrayList<Field>();
 Class<?> i = type;
 while (i != null && i != Object.class) {
 Collections.addAll(result, i.getDeclaredFields());
 i = i.getSuperclass();
 }
 return result;
}

If you use a code coverage tool like EclEmma, you have to watch out: they add a hidden field to each of your classes. In the case of EclEmma, these fields are marked synthetic, and you can filter them out like this:

private List<Field> getInheritedPrivateFields(Class<?> type) {
 List<Field> result = new ArrayList<Field>();
 Class<?> i = type;
 while (i != null && i != Object.class) {
 for (Field field : i.getDeclaredFields()) {
 if (!field.isSynthetic()) {
 result.add(field);
 }
 }
 i = i.getSuperclass();
 }
 return result;
}

• Anatoliy: Thanks for your remark about synthetic fields, EMMA does the same.
• Peter Hawkins: this gets declared and inherited fields of the argument class so should be named getDeclaredAndInheritedPrivateFields. perfect though thanks!
• Lucas Crawford: nice catch on the isSynthetic :)

Answer 4

public static Field getField(Class<?> clazz, String fieldName) {
 Class<?> tmpClass = clazz;
 do {
 try {
 Field f = tmpClass.getDeclaredField(fieldName);
 return f;
 } catch (NoSuchFieldException e) {
 tmpClass = tmpClass.getSuperclass();
 }
 } while (tmpClass != null);
 throw new RuntimeException("Field '" + fieldName
 + "' not found on class " + clazz);
}

(based on this answer)

Answer 5

In fact i use a complex type hierachy so you solution is not complete. I need to make a recursive call to get all the private inherited fields. Here is my solution

 /**
 * Return the set of fields declared at all level of class hierachy
 */
public static List<Field> getAllFields(Class<?> clazz) {
 return getAllFieldsRec(clazz, new ArrayList<>());
}
private static List<Field> getAllFieldsRec(Class<?> clazz, List<Field> list) {
 Class<?> superClazz = clazz.getSuperclass();
 if (superClazz != null) {
 getAllFieldsRec(superClazz, list);
 }
 list.addAll(Arrays.asList(clazz.getDeclaredFields()));
 return list;
}

• aperkins: However, his solution did get you on the right path, didn't it?
• Sean Patrick Floyd: Vector is bad old code. Please use a current data structure from the collections framework (ArrayList is adequate in most cases)
• benzen: @aperkins the answer of aioobe look like mine, but i found it and then i saw the answer. @seanizer Vector is not that old, and it'a a member of the collection API
• Sean Patrick Floyd: "As of the Java 2 platform v1.2, this class has been retrofitted to implement List, so that it becomes a part of Java's collection framework." retrofitted in 1.2? if that's not old then what is? Source: download.oracle.com/javase/1.4.2/docs/api/java/util/Vector.html
• Sean Patrick Floyd: Vector has a huge overhead because everything is synchronized. And where you need synchronization, there are better classes in java.util.concurrent. Vector, Hashtable and StringBuffer should in most cases be replaced by ArrayList, HashMap and StringBuilder

Answer 6

private static Field getField(Class<?> clazz, String fieldName) {
 Class<?> tmpClass = clazz;
 do {
 for ( Field field : tmpClass.getDeclaredFields() ) {
 String candidateName = field.getName();
 if ( ! candidateName.equals(fieldName) ) {
 continue;
 }
 field.setAccessible(true);
 return field;
 }
 tmpClass = tmpClass.getSuperclass();
 } while ( clazz != null );
 throw new RuntimeException("Field '" + fieldName +
 "' not found on class " + clazz);
}

Answer 7

I needed to add support for inherited fields for blueprints in Model Citizen. I derived this method that is a bit more concise for retrieving a Class' fields + inherited fields.

private List<Field> getAllFields(Class clazz) {
 List<Field> fields = new ArrayList<Field>();
 fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
 Class superClazz = clazz.getSuperclass();
 if(superClazz != null){
 fields.addAll(getAllFields(superClazz));
 }
 return fields;
}

Answer 8

Commons Lang has the util method FieldUtils#getAllFieldsList for this.