Java Reflection — Private Fields and Methods
Despite the common belief it is actually possible to access private fields and methods of other classes via Java Reflection. It is not even that difficult. This can be very handy during unit testing. This text will show you how.
Note: This only works when running the code as a standalone Java application, like you do with unit tests and regular applications. If you try to do this inside a Java Applet, you will need to fiddle around with the SecurityManager. But, since that is not something you need to do very often, it is left out of this text so far.
Note: There has been a lot of talk about disabling the ability to access private fields via reflection from Java 9. From my experiments it seems to still be possible in Java 9, but be aware that this might change in a future Java version.
Accessing Private Fields
To access a private field you will need to call the Class.getDeclaredField(String name) or Class.getDeclaredFields() method. The methods Class.getField(String name) and Class.getFields() methods only return public fields, so they won’t work. Here is a simple example of a class with a private field, and below that the code to access that field via Java Reflection:
public class PrivateObject < private String privateString = null; public PrivateObject(String privateString) < this.privateString = privateString; >>
PrivateObject privateObject = new PrivateObject("The Private Value"); Field privateStringField = PrivateObject.class. getDeclaredField("privateString"); privateStringField.setAccessible(true); String fieldValue = (String) privateStringField.get(privateObject); System.out.println("fieldValue fieldValue = The Private Value", which is the value of the private field privateString of the PrivateObject instance created at the beginning of the code sample. Notice the use of the method PrivateObject.class.getDeclaredField("privateString"). It is this method call that returns the private field. This method only returns fields declared in that particular class, not fields declared in any superclasses.
Notice the line in bold too. By calling Field.setAcessible(true) you turn off the access checks for this particular Field instance, for reflection only. Now you can access it even if it is private, protected or package scope, even if the caller is not part of those scopes. You still can't access the field using normal code. The compiler won't allow it.
Accessing Private Methods
To access a private method you will need to call the Class.getDeclaredMethod(String name, Class[] parameterTypes) or Class.getDeclaredMethods() method. The methods Class.getMethod(String name, Class[] parameterTypes) and Class.getMethods() methods only return public methods, so they won't work. Here is a simple example of a class with a private method, and below that the code to access that method via Java Reflection:
public class PrivateObject < private String privateString = null; public PrivateObject(String privateString) < this.privateString = privateString; >private String getPrivateString() < return this.privateString; >>
PrivateObject privateObject = new PrivateObject("The Private Value"); Method privateStringMethod = PrivateObject.class. getDeclaredMethod("getPrivateString", null); privateStringMethod.setAccessible(true); String returnValue = (String) privateStringMethod.invoke(privateObject, null); System.out.println("returnValue returnValue = The Private Value", which is the value returned by the method getPrivateString() when invoked on the PrivateObject instance created at the beginning of the code sample.
Notice the use of the method PrivateObject.class.getDeclaredMethod("privateString") . It is this method call that returns the private method. This method only returns methods declared in that particular class, not methods declared in any superclasses.
Notice the line in bold too. By calling Method.setAcessible(true) you turn off the access checks for this particular Method instance, for reflection only. Now you can access it even if it is private, protected or package scope, even if the caller is not part of those scopes. You still can't access the method using normal code. The compiler won't allow it.
Tech Tutorials
Tutorials and posts about Java, Spring, Hadoop and many more. Java code examples and interview questions. Spring code examples.
Tuesday, February 9, 2021
Invoke Method at Runtime Using Java Reflection API
In this post we’ll see how to invoke a method at runtime using Java reflection API. You can even call a private method using reflection.
How to get the method instance
- getMethod(String name, Class. parameterTypes)- Using getMethod() you can get a Method object for the specified public member method of the class (instance or static). As method arguments pass the method name and the type of the method parameters.
- getMethods()- This method returns an array containing Method objects for all the public methods of the class even the inherited ones.
- getDeclaredMethod(String name, Class. parameterTypes)- Using getDeclaredMethod() you can get a Method object for the specified method of the class (having any access modifier public, private, protected, default).
- getDeclaredMethods()- This method returns an array containing Method objects for all the declared methods of the class including public, protected, default (package) access, and private methods, but excluding inherited methods.
How to invoke method using Java reflection API
Once you have a Method instance using any of the above mentioned methods, you can invoke method of the class by calling java.lang.reflect.Method.invoke().
First argument to the invoke method is the object instance on which this particular method is to be invoked i.e. object of the class where the method resides. If the method called is static, first argument should be null. Subsequent arguments are the method's parameters.
In case underlying method throws an exception, it will be wrapped by an java.lang.reflect.InvocationTargetException.
Invoking class methods using Java reflection API example
As a preparation for the example code let’s have a class called TestClass.java with methods that are invoked using Java reflection API.
public class TestClass < public String appendString(String str1, String str2) < return str1+ " " +str2; >static int addValues(int a, int b) < return a+b; >private boolean compare(int a, int b) < return a >b; > >
Invoking instance method using Java reflection API example
If you have to invoke the public method appendString() of the given class then it can be done using the following method-
public void callMethod() < Classc = null; String result=""; try < // Getting Class instance c = Class.forName("org.netjs.prog.TestClass"); // Getting class object TestClass obj = new TestClass(); Method method = null; // getting method instance by passing method name and parameter types method = c.getDeclaredMethod("appendString", String.class, String.class); // invoking method result = (String)method.invoke(obj, "Hello", "World"); >catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) < // TODO Auto-generated catch block e.printStackTrace(); >System.out.println("Returned result is- " + result); > Returned result is- Hello World
Invoking static method of a class
If you have to invoke a static method of a class then while calling the invoke method pass the first argument (which denotes the class object) as null.
public void callMethod() < Classc = null; int result = 0; try < // Getting Class instance c = Class.forName("org.netjs.prog.TestClass"); // Getting class object TestClass obj = new TestClass(); Method method = null; // getting method instance by passing method name and parameter types method = c.getDeclaredMethod("addValues", int.class, int.class); // invoking method result = (Integer)method.invoke(null, 20, 30); >catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) < // TODO Auto-generated catch block e.printStackTrace(); >System.out.println("Returned result is- " + result); > Invoking private method using Java reflection API
You can even invoke the private method of the class using reflection in Java.
Using getDeclaredMethod() you can get the private method of the class. Once you have the method object you can use the setAccessible() method which is inherited from class java.lang.reflect.AccessibleObject to set the access for the private method as true at run time and then invoke it from another class.
public void callMethod() < Classc = null; boolean result = false; try < // Getting Class instance c = Class.forName("org.netjs.prog.TestClass"); // Getting class object TestClass obj = new TestClass(); Method method = null; // getting method instance by passing method name and parameter types method = c.getDeclaredMethod("compare", int.class, int.class); // Making method accessible method.setAccessible(true); // invoking private method of the class result = (Boolean)method.invoke(obj, 60, 30); >catch (ClassNotFoundException | NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) < // TODO Auto-generated catch block e.printStackTrace(); >System.out.println("Returned result is- " + result); > That's all for this topic Invoke Method at Runtime Using Java Reflection API. If you have any doubt or any suggestions to make please drop a comment. Thanks!
Can we override private methods in Java?
Let us first consider the following Java program as a simple example of Overriding or Runtime Polymorphism.
Java
The program prints “Derived fun”.
The Base class reference ‘obj’ refers to a derived class object (see expression “Base obj = new Derived()”). When fun() is called on obj, the call is made according to the type of referred object, not according to the reference.
Is Overriding possible with private methods?
Predict the output of the following program.
Java
We get compiler error “fun() has private access in Base” (See this). So the compiler tries to call base class function, not derived class, means fun() is not overridden.
An inner class can access private members of its outer class. What if we extend an inner class and create fun() in the inner class?
An Inner class can access private members of its outer class, for example in the following program, fun() of Inner accesses private data member msg which is fine by the compiler.
Java
Accessing Private Member of Outer: GeeksforGeeks Outer fun()
In the above program, we created an outer class and an inner class. We extended Inner from Outer and created a method fun() in both Outer and Inner. If we observe our output, then it is clear that the method fun() has not been overridden. It is so because private methods are bonded during compile time and it is the type of the reference variable – not the type of object that it refers to – that determines what method to be called.. As a side note, private methods may be performance-wise better (compared to non-private and non-final methods) due to static binding.
Comparison With C++
1) In Java, inner Class is allowed to access private data members of outer class. This behavior is same as C++ (See this).
2) In Java, methods declared as private can never be overridden, they are in-fact bounded during compile time. This behavior is different from C++. In C++, we can have virtual private methods (See this).
This article is contributed by Chandra Prakash. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.