How to Get Information About the Local Variables Using Java Reflection

Can I get information about the local variables using Java reflection?

Assuming that you are talking about a method or constructor's local variables, you cannot find out about them using reflection. You have to either

use a bytecode library such as BCEL or ASM, or
use one of the remote debugger APIs.

The latter will allow you to access the values of the local variables, but only while the JVM is suspended by the debug agent.

Both of these approaches rely on the classes in question being compiled with debug information. Specifically, the classes need to be compiled with "local variable debugging information"; e.g. using javac -g .... The "vars" debug information is not included by default.

Accessing local variables in the main method via reflection

Since main is static, is it possible to access instanceOfB in order to access the value of _nonStaticInt?

"No." Local variables (being in a static method or not) cannot be accessed with the Java Reflection API. Reflection only works at the type level, not the byte-code level².

The stated understanding of the linked question is correct; reflection access of a non-static (instance) field logically requires an instance. That is, the issue then isn't about reflecting on the B type, the issue is about obtaining the B instance (which is assigned to a local variable) to reflect upon.

To do this the B instance has to be "bled" somehow - e.g. assigned to a static field or passed as an argument to a method/constructor from main¹ - so that it can be used with reflection later as the object who's instance members are to be accessed.

The cleanest approach would probably be to pass the B instance down through the appropriate context (or "DI"), perhaps with the aide of IoC .. and maybe changing the type to avoid the use of reflection entirely.

¹ Another possible way to "bleed" the B instance is to attach a debugger and inspect/use the local variable within the main methods executing frame - but this sounds like trying to swat a fly with a club.

² Even tooling like BCEL/ASM wouldn't immediately help during the execution of the main method. Rather it would be used to deconstruct the method, add in the required hooks/code to "bleed" or use the instance created, and then construct a modified method to execute.

Can a method variable be accessed using reflection?

You can't. If it's defined in a method, is it a local variable defined in that scope only. Since the method had no state outside of its scope, you have nothing to access.

Accessing a class member (which, by definition, is a state) you can access via "regular" reflection.

how to get all variable and type data in class and method using java

You can use the methods Class.getDeclaredMethods() and Class.getDeclaredFields() from the Reflection API to list a class methods and attributes.

for (Method m : ExampleClass.class.getDeclaredMethods()) {
    System.out.println(m.getName() + ": " + m.getGenericReturnType());
}

for (Field f : ExampleClass.class.getDeclaredFields()) {
    System.out.println(f.getName() + ": " + f.getType());
}

But you can not normally access the local variables information. In Java 8, you have access to the methods parameters using the method Method.getParameters(). So you could do:

for (Method m : ExampleClass.class.getDeclaredMethods()) {
    for (Parameter p : m.getParameters()) {
        System.out.println(p.getName() + ": " + p.getType());
    }
}

The parameter names are not stored by default in the .class files though, so the parameters will be listed as arg0, arg1, etc. To get the real parameter names you need to compile the source file with the -parameters option to the javac compiler.

Java Reflection: How to get the name of a variable?

As of Java 8, some local variable name information is available through reflection. See the "Update" section below.

Complete information is often stored in class files. One compile-time optimization is to remove it, saving space (and providing some obsfuscation). However, when it is is present, each method has a local variable table attribute that lists the type and name of local variables, and the range of instructions where they are in scope.

Perhaps a byte-code engineering library like ASM would allow you to inspect this information at runtime. The only reasonable place I can think of for needing this information is in a development tool, and so byte-code engineering is likely to be useful for other purposes too.

Update: Limited support for this was added to Java 8. Parameter (a special class of local variable) names are now available via reflection. Among other purposes, this can help to replace @ParameterName annotations used by dependency injection containers.

Is it possible to get access to local variable of method in runtime with Reflection API or with some other things?

Local variables only exist while the method is running, and there's a separate copy in each activation of the method. Since the reflection API doesn't reflect method activations, you can't get methods' local variables via reflection.

how to get local variables of a method from another class

thanks for your support.
I found the answer myself.
I can do this via Java Regex Concept.
As I know a little about the variable's naming pattern,
So I am planning to parse the class1.java file and first will try pattern matching the method name and then the variables name.
So that I will get the line on which the variable is declared.
for example, if my variable is object,
String abc=new String();

I will try regex like, String regex=".=new.().*"

So this will fulfill my purpose.
Thanks again for helping.

How do I list all local variables within a Java method / function?

You can't, as far as I'm aware. At least, not with normal Java code. If you're able to run the bytecode through some sort of post-processor before running it, and assuming you're still building with the debug symbols included, then you could autogenerate the code to do it - but I don't believe there's any way of accessing local variables in the current stack frame via reflection.