Java Reflection for Methods

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Java Reflection is a powerful feature that allows us to inspect and manipulate the runtime behavior of applications. Reflection can be used to get information about classes, methods, and fields at runtime, even if they are not accessible at compile-time. In this article, we'll focus on how to use Java Reflection to work with methods.

Introduction to Java Reflection

Reflection is a feature in Java that allows us to examine or modify the runtime behavior of applications. It is provided by the java.lang.reflect package and allows us to:

• Analyze a class and its members, including fields and methods.
• Instantiate objects, invoke methods, and access fields dynamically.

Working with Methods using Java Reflection

Getting Method Information

We can retrieve method information from a class using the Method class in the java.lang.reflect package. Here's an example of how to get method information:

import java.lang.reflect.Method; public class ReflectionExample { public static void main(String[] args) { try { // Get the Class object associated with the class Class<?> clazz = Class.forName("java.util.ArrayList"); // Get all the methods of the class Method[] methods = clazz.getDeclaredMethods(); // Print method information for (Method method : methods) { System.out.println("Method Name: " + method.getName()); System.out.println("Return Type: " + method.getReturnType()); System.out.println("Parameter Count: " + method.getParameterCount()); System.out.println("Parameter Types: "); Class<?>[] parameterTypes = method.getParameterTypes(); for (Class<?> parameterType : parameterTypes) { System.out.println(parameterType.getName()); } System.out.println("-----------"); } } catch (ClassNotFoundException e) { e.printStackTrace(); } } } 

Invoking Methods Using Reflection

We can also invoke methods dynamically using reflection. Here is an example of how to invoke a method using reflection:

import java.lang.reflect.Method; public class ReflectionInvokeExample { public static void main(String[] args) { try { // Create an instance of the class Class<?> clazz = Class.forName("java.util.ArrayList"); Object instance = clazz.getDeclaredConstructor().newInstance(); // Get the method to be invoked Method addMethod = clazz.getDeclaredMethod("add", Object.class); // Invoke the method addMethod.invoke(instance, "Reflection Example"); // Get and invoke the size method to check if the element was added Method sizeMethod = clazz.getDeclaredMethod("size"); int size = (int) sizeMethod.invoke(instance); System.out.println("Size of the list: " + size); } catch (Exception e) { e.printStackTrace(); } } } 

Example with Custom Class

Let's create a custom class and use reflection to get method information and invoke methods.

Custom Class:

public class CustomClass { private String message; public CustomClass() { this.message = "Hello, Reflection!"; } public void setMessage(String message) { this.message = message; } public String getMessage() { return message; } private void printMessage() { System.out.println("Message: " + message); } } 

Reflection Example:

import java.lang.reflect.Method; public class CustomClassReflection { public static void main(String[] args) { try { // Create an instance of CustomClass Class<?> clazz = CustomClass.class; Object instance = clazz.getDeclaredConstructor().newInstance(); // Get and invoke public methods Method setMessageMethod = clazz.getDeclaredMethod("setMessage", String.class); setMessageMethod.invoke(instance, "Updated Message through Reflection"); Method getMessageMethod = clazz.getDeclaredMethod("getMessage"); String message = (String) getMessageMethod.invoke(instance); System.out.println("Message: " + message); // Access and invoke private method Method printMessageMethod = clazz.getDeclaredMethod("printMessage"); printMessageMethod.setAccessible(true); // Access private method printMessageMethod.invoke(instance); } catch (Exception e) { e.printStackTrace(); } } } 

Output:

Message: Updated Message through Reflection Message: Updated Message through Reflection 

Conclusion

Java Reflection provides a powerful way to inspect and manipulate methods at runtime. It can be used for various purposes such as testing, debugging, and developing frameworks. However, it should be used with caution due to its potential impact on performance and security. By understanding how to work with methods using reflection, you can leverage this powerful feature in your Java applications.

For more information on Java Reflection, you can refer to the official Java Reflection API documentation.