Reflection

Question 1

What is reflection in Java?

Answer 1

Reflection is the ability of a program to inspect and manipulate classes, methods, fields, and constructors at runtime.

Question 2

What package provides reflection functionality?

Answer 2

java.lang.reflect.

Question 3

What can reflection be used for?

Answer 3

Inspecting class metadata, invoking methods, accessing fields, and creating objects dynamically.

Question 4

When does reflection operate?

Answer 4

At runtime.

Question 5

Why is reflection powerful?

Answer 5

It allows dynamic behavior without knowing class details at compile time.

Question 6

Example use of reflection?

Answer 6

Loading a class by name using Class.forName(“MyClass”).

Question 7

Can reflection access private members?

Answer 7

Yes. Using setAccessible(true), though it may break encapsulation.

Question 8

How does reflection help frameworks?

Answer 8

It allows frameworks like Spring or Hibernate to inspect classes dynamically.

Question 9

Can reflection create objects?

Answer 9

Yes. Using Constructor.newInstance().

Question 10

Can reflection call methods dynamically?

Answer 10

Yes. Using Method.invoke().

Question 11

Does reflection affect performance?

Answer 11

Yes. It is slower than direct method calls.

Question 12

Why is reflection slower?

Answer 12

Because operations are resolved dynamically rather than at compile time.

Question 13

Is reflection safe to use everywhere?

Answer 13

No. It should be used carefully due to performance and security concerns.

Question 14

What security risk does reflection pose?

Answer 14

It can bypass access control and modify private data.

Question 15

When should reflection be used?

Answer 15

When dynamic behavior is required and cannot be achieved through normal code.

Question 16

Key rule to remember?

Answer 16

Reflection = runtime inspection and dynamic invocation.

Question 17

What are the main uses of reflection in Java?

Answer 17

Reflection is used for runtime inspection, dynamic object creation, method invocation, and framework automation.

Question 18

Why is reflection useful in testing?

Answer 18

It allows test frameworks to access private methods and fields for validation.

Question 19

How do IDEs use reflection?

Answer 19

IDEs use it to analyze classes, detect methods, and provide features like autocomplete and code inspection.

Question 20

Why is reflection helpful for debugging?

Answer 20

It allows runtime inspection of object state and structure.

Question 21

How do frameworks use reflection?

Answer 21

Frameworks like Spring and Hibernate use reflection to scan classes, inject dependencies, and map objects dynamically.

Question 22

Why is reflection important for dynamic programs?

Answer 22

It enables programs to load and interact with classes not known at compile time.

Question 23

Which Java feature supports runtime class loading?

Answer 23

Class.forName().

Question 24

How is reflection used in plugin systems?

Answer 24

It loads and executes external modules dynamically.

Question 25

Why is reflection used in serialization libraries?

Answer 25

To inspect object fields and convert them automatically.

Question 26

How does reflection help dependency injection?

Answer 26

It allows frameworks to discover constructors and inject required objects.

Question 27

Can reflection be used for annotations processing?

Answer 27

Yes. Reflection can read annotations at runtime.

Question 28

Is reflection used in XML or JSON parsing frameworks?

Answer 28

Yes. Parsers use reflection to map data to object fields.

Question 29

Does reflection enable dynamic method invocation?

Answer 29

Yes. Methods can be invoked using Method.invoke().

Question 30

Why should reflection be used cautiously?

Answer 30

It reduces performance and may break encapsulation.

Question 31

When is reflection most appropriate?

Answer 31

When flexibility and runtime adaptability are required.

Question 32

Key rule to remember?

Answer 32

Reflection enables dynamic runtime inspection and execution.

Question 33

How can you access a private method from outside a class in Java?

Answer 33

By using reflection to obtain the Method object, make it accessible, and invoke it.

Question 34

Which API is used to access private methods via reflection?

Answer 34

java.lang.reflect.Method.

Question 35

How do you obtain a private method using reflection?

Answer 35

Call Class.getDeclaredMethod("methodName", parameterTypes).

Question 36

Why use getDeclaredMethod instead of getMethod?

Answer 36

getDeclaredMethod retrieves private methods, while getMethod retrieves only public ones.

Question 37

What does setAccessible(true) do?

Answer 37

It bypasses Java access checks to allow access to private members.

Question 38

How do you invoke a private method using reflection?

Answer 38

Call method.invoke(objectInstance, arguments).

Question 39

Example flow for calling private method?

Answer 39

Load class → create instance → get method → set accessible → invoke.

Question 40

What exception may occur when using reflection incorrectly?

Answer 40

NoSuchMethodException, IllegalAccessException, InvocationTargetException.

Question 41

Can reflection access private fields as well?

Answer 41

Yes. Using Field and setAccessible(true).

Question 42

Is accessing private methods via reflection recommended?

Answer 42

Generally no. It breaks encapsulation and should be used only when necessary.

Question 43

Why do frameworks use reflection to access private members?

Answer 43

To inject dependencies or configure objects dynamically.

Question 44

Does reflection ignore compile-time access rules?

Answer 44

Yes. Access checks can be bypassed at runtime.

Question 45

What security risk exists when accessing private methods?

Answer 45

It can expose internal logic and sensitive data.

Question 46

Can reflection call static private methods?

Answer 46

Yes. Pass null as object instance when invoking.

Question 47

Does reflection affect performance?

Answer 47

Yes. Reflection calls are slower than direct method calls.

Question 48

Key rule to remember?

Answer 48

Reflection can access private methods by overriding access checks.

Question 49

How can we access private method of a class from outside the class?

Answer 49

We can use Reflection to access private method of a class from outside the class. IN Java, we use getDeclaredMethod() to get instance of a private method. Then we mark this method accessible and finally invoke it. In following sample code, we are accessing private method message() of class Foo by Reflection. FileName: Foo.java public class Foo { private void message(){System.out.println("hello java"); } } FileName: FooMethodCall.java import java.lang.reflect.Method; public class FooMethodCall{ public static void main(String[] args)throws Exception{ Class c = Class.forName("Foo"); Object o= c.newInstance(); Method m =c.getDeclaredMethod("message", null); m.setAccessible(true); m.invoke(o, null); } }

Question 50

How can you create an object dynamically at runtime in Java?

Answer 50

By using reflection to load a class and instantiate it using Constructor.newInstance().

Question 51

What class is used to dynamically load classes?

Answer 51

Class.

Question 52

Which method loads a class by name?

Answer 52

Class.forName("ClassName").

Question 53

How do you create an instance using reflection?

Answer 53

Class c = Class.forName("MyClass"); Object obj = c.getDeclaredConstructor().newInstance();

Question 54

What is the modern recommended method for instantiation?

Answer 54

getDeclaredConstructor().newInstance().

Question 55

Why is Class.newInstance() discouraged?

Answer 55

It is deprecated because it suppresses checked exceptions and has limited flexibility.

Question 56

What does Constructor.newInstance() allow?

Answer 56

It lets you call constructors with parameters.

Question 57

Example of constructor reflection?

Answer 57

Constructor cons = c.getConstructor(String.class); Object obj = cons.newInstance("value");

Question 58

Can reflection instantiate private constructors?

Answer 58

Yes. By calling setAccessible(true).

Question 59

Why create objects dynamically?

Answer 59

When class name is not known until runtime.

Question 60

Where is dynamic instantiation commonly used?

Answer 60

Frameworks, plugin systems, dependency injection containers.

Question 61

What exception occurs if class name is wrong?

Answer 61

ClassNotFoundException.

Question 62

What exception occurs if constructor not found?

Answer 62

NoSuchMethodException.

Question 63

Does dynamic instantiation require compile-time knowledge of class?

Answer 63

No. Only class name string is needed.

Question 64

Does reflection-based instantiation affect performance?

Answer 64

Yes. It is slower than normal object creation.

Question 65

Is dynamic instantiation type-safe?

Answer 65

No. Casting is usually required after creation.

Question 66

Key rule to remember?

Answer 66

Runtime object creation = Class loading + constructor invocation via reflection.