What is reflection in java with an example javatpoint

What is reflection in java with an example javatpoint

I'll respond in English this time!

Reflection in Java is a mechanism that allows a program to examine and modify the behavior of other objects at runtime. This means you can inspect and manipulate classes, interfaces, constructors, methods, fields, and even arrays dynamically. Reflection is particularly useful for tasks such as:

To use reflection in Java, you need to:

Let's illustrate this with an example from javatpoint:

// Example: Reflection usage
public class Student {
private String name;
public Student(String name) { this.name = name; }
public void sayHello() { System.out.println("Hello, my name is " + name); }
}
class Main {
public static void main(String[] args) throws Exception {
// Step 1: Get the Student class
Class studentClass = Class.forName("Student");
// Step 2: Get a constructor with one String argument
Constructor constructor = studentClass.getConstructor(String.class);
// Step 3: Create an instance using the constructor
Object obj = constructor.newInstance("John");
Student student = (Student) obj;
// Step 4: Get the sayHello() method and invoke it
Method method = studentClass.getMethod("sayHello", (Class[]) null);
method.invoke(student); // Output: Hello, my name is John
// Step 5: Get the private field "name" using reflection
Field field = studentClass.getDeclaredField("name");
field.setAccessible(true); // Make it accessible
System.out.println(field.get(student)); // Output: John
// Example of dynamic method invocation:
Method setterMethod = studentClass.getMethod("setName", String.class);
setterMethod.invoke(student, "Jane"); // Change the name to Jane
System.out.println(field.get(student)); // Output: Jane
}
}

This example demonstrates the following reflection features:

Remember that using reflection can lead to security concerns if not used carefully, as it allows for manipulation of sensitive data or execution of unauthorized code.

What is reflection in java with an example interview questions

Reflection!

In Java, Reflection refers to the ability of a program to examine and modify its own structure and behavior at runtime. It's a powerful feature that allows you to inspect and manipulate objects, classes, and interfaces.

What can I do with Reflection?

Example: Reflective Calculator

Suppose we have a simple calculator with two methods:

public class Calculator {
public int add(int x, int y) { return x + y; }
public double multiply(double x, double y) { return x * y; }
}

Using Reflection, we can create an instance of Calculator, get information about its methods, and even invoke them programmatically.

Here's a simple example:

import java.lang.reflect.Method;
public class ReflectiveCalculator {
public static void main(String[] args) throws Exception {
// Create Calculator instance
Calculator calculator = new Calculator();
// Get add() method using Reflection
Method addMethod = Calculator.class.getMethod("add", int.class, int.class);
// Invoke add() method with 2 and 3 as arguments
int result = (int) addMethod.invoke(calculator, 2, 3);
System.out.println("Result of 2+3: " + result);  // prints 5
// Get multiply() method using Reflection
Method multiplyMethod = Calculator.class.getMethod("multiply", double.class, double.class);
// Invoke multiply() method with 4.5 and 2.7 as arguments
double resultDouble = (double) multiplyMethod.invoke(calculator, 4.5, 2.7);
System.out.println("Result of 4.5*2.7: " + resultDouble);  // prints 12.15
}
}

Interview Questions

Here are some common Reflection-related interview questions:

Bonus Question

Remember to be ready to discuss your thoughts on Reflection, its applications, and any potential trade-offs or limitations!