How to loop over a Class attributes in Java?

Question

How can I loop over a class attributes in java dynamically.

For eg :

public class MyClass{     private type1 att1;     private type2 att2;     ...      public void function(){         for(var in MyClass.Attributes){             System.out.println(var.class);         }     } } 

is this possible in Java?

Answer 1

There is no linguistic support to do what you're asking for.

You can reflectively access the members of a type at run-time using reflection (e.g. with Class.getDeclaredFields() to get an array of Field), but depending on what you're trying to do, this may not be the best solution.

See also

• Java Tutorials: Reflection API / Advanced Language Topics: Reflection

Related questions

• What is reflection, and why is it useful?
• Java Reflection: Why is it so bad?
• How could Reflection not lead to code smells?
• Dumping a java object’s properties

---

Example

Here's a simple example to show only some of what reflection is capable of doing.

import java.lang.reflect.*;  public class DumpFields {     public static void main(String[] args) {         inspect(String.class);     }     static <T> void inspect(Class<T> klazz) {         Field[] fields = klazz.getDeclaredFields();         System.out.printf("%d fields:%n", fields.length);         for (Field field : fields) {             System.out.printf("%s %s %s%n",                 Modifier.toString(field.getModifiers()),                 field.getType().getSimpleName(),                 field.getName()             );         }     } } 

The above snippet uses reflection to inspect all the declared fields of class String; it produces the following output:

7 fields: private final char[] value private final int offset private final int count private int hash private static final long serialVersionUID private static final ObjectStreamField[] serialPersistentFields public static final Comparator CASE_INSENSITIVE_ORDER 

---

Effective Java 2nd Edition, Item 53: Prefer interfaces to reflection

These are excerpts from the book:

Given a Class object, you can obtain Constructor, Method, and Field instances representing the constructors, methods and fields of the class. [They] let you manipulate their underlying counterparts reflectively. This power, however, comes at a price:

• You lose all the benefits of compile-time checking.
• The code required to perform reflective access is clumsy and verbose.
• Performance suffers.

As a rule, objects should not be accessed reflectively in normal applications at runtime.

There are a few sophisticated applications that require reflection. Examples include [...omitted on purpose...] If you have any doubts as to whether your application falls into one of these categories, it probably doesn't.