Java: How to Access a Class's Field by a Name Stored in a Variable

Java: How can I access a class's field by a name stored in a variable?

You have to use reflection:

• Use Class.getField() to get a Field reference. If it's not public you'll need to call Class.getDeclaredField() instead
• Use AccessibleObject.setAccessible to gain access to the field if it's not public
• Use Field.set() to set the value, or one of the similarly-named methods if it's a primitive

Here's an example which deals with the simple case of a public field. A nicer alternative would be to use properties, if possible.

import java.lang.reflect.Field;

class DataObject
{
    // I don't like public fields; this is *solely*
    // to make it easier to demonstrate
    public String foo;
}

public class Test
{
    public static void main(String[] args)
        // Declaring that a method throws Exception is
        // likewise usually a bad idea; consider the
        // various failure cases carefully
        throws Exception
    {
        Field field = DataObject.class.getField("foo");
        DataObject o = new DataObject();
        field.set(o, "new value");
        System.out.println(o.foo);
    }
}

accessing fields of a class in Java

What you're doing does not work because you're not declaring the member field as public:

public String fruitname = "grapes";

Only then you can even compile this:

System.out.println("person is eating " + f.fruitname);

Note that in Java fields are package private per default (see also). This means that the field can be private but in this case you can only access this field in classes which reside in the same package.

---

However, in general one creates getter and setter methods like this:

public class Fruit {

    private String fruitname = "grapes";

    public String getFruitname() {
        return fruitname;
    }

    public void setFruitname(String fruitname) {
        this.fruitname = fruitname;
    }
}

which will allow you to access the class member fruitname like this:

public class Person {
    public void eat(Fruit f) {
        System.out.println("person is eating " + f.getFruitname());
    }
}

Depending on your IDE you might be able to right click the field (or somewhere in the class) and find something like Generate.. > Getters & Setters which makes the whole act less annoying.

Get all variable names in a class

Field[] fields = YourClassName.class.getFields();

returns an array of all public variables of the class.

getFields() return the fields in the whole class-heirarcy. If you want to have the fields defined only in the class in question, and not its superclasses, use getDeclaredFields(), and filter the public ones with the following Modifier approach:

Modifier.isPublic(field.getModifiers());

The YourClassName.class literal actually represents an object of type java.lang.Class. Check its docs for more interesting reflection methods.

The Field class above is java.lang.reflect.Field. You may take a look at the whole java.lang.reflect package.

Get name of a field

Unfortunately, there is no way to do what you wish. Why?

In an era where we are still trying to prove that Java is not slow, storing metadata of where or how an object was constructed would have a large overhead, and since it has a very minimal range of use, it does not exist. Not only that: there are a bunch of technical reasons as well.

One reason is because of how the JVM is implemented. The specification for the Java class file format can be found here. It's quite a mouthful, but it is very informative.

As I said previously, an object can be constructed from anywhere, even situations where objects do not have names. Only objects defined as class members have names (for the obvious reason of access): objects constructed in methods do not. The JVM has a local variable table with a maximum of 65535 entries. These are loaded unto the stack and stored into the table via the *load and *store opcodes.

In other words, a class like

public class Test {
int class_member = 42;

   public Test() {
      int my_local_field = 42;
   }
}

gets compiled into

public class Test extends java.lang.Object
  SourceFile: "Test.java"
  minor version: 0
  major version: 50
  Constant pool:
  --snip--

{
int class_member;

public Test();
  Code:
   Stack=2, Locals=2, Args_size=1
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  42
   7:   putfield        #2; //Field class_member:I
   10:  bipush  42
   12:  istore_1
   13:  return
  LineNumberTable:
   --snip--    
}

There, you can see a clear example from javap -v Test that while the name class_memberis preserved, the my_local_field has been abstracted to index 1 in the local variable table (0 is reserved for this).

This in itself would be a pain for debuggers and such, so a set of attributes (think metadata for class files) was designed. These include the LocalVariableTable, LineNumberTable, and LocalVariableTypeTable. These attributes are useful for stacktraces (LineNumberTable), and debuggers (LocalVariableTable and LocalVariableTypeTable). However, these are completely optional to include in files, and there is no guarantee that they are:

The LineNumberTable attribute is an optional variable-length attribute
in the attributes table

The same holds for the rest of them.

Additionally, most compilers do not produce anything but the LineNumberTable by default, so you'd be out of luck even if it was possible.

Basically, it would be quite frustrating for developers to have a getFieldName(object) (which wouldn't be possible in the first place for local variables), and only have it work when those attributes are present.

So you are stuck for the foreseeable future with using getField with Strings. Shameless plug: IntelliJ seems to handle refactors with reflection quite well: having written Minecraft mods as well I know the feeling, and can say that work in refactoring is significantly reduces by IntelliJ. But the same is probably true for most modern IDEs: I'm sure the big players, Eclipse, Netbeans et al. have well-implemented refactoring systems in place.

How to get value from List giving String as variable name

You need a Map<String, Function<Contact, String>> containing method references, keyed by the property name.

For example:

// Construct this once, store in a static final field.
Map<String, Function<Contact, String> map =
    Map.of("name", c -> c.name /* etc for other fields */);

// Then, when you want to get the value:
String val = map.get(var).apply(contactList.get(0));

Java: refer to a class variable using a variable

You could also introduce a Map that holds a reference based on the name:

import java.util.*;

public class Lists_of_values {
    public static List<String> circumstances = Arrays.asList("Medical", "Maternity", "Bereavement", "Other");
    public static List<String> interruptions = Arrays.asList("Awaiting results", "Courses not available", "Fieldwork", "Health reasons", "Internship with stipend", "Other");

    private static Map<String, List<String>> lists = new HashMap<>();
    static {
        lists.put("circumstances", circumstances);
        lists.put("interruptions", interruptions);
    }

    public static List<String> getList(String name) {
        return lists.get(name);
    }
}

That would be used as: List_of_Values.getList("circumstances")

This would also allow your code to be obfuscated, which would break if you decide to use reflection.

---

Related Topics