Products

Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller

Developer

Article Blog Forum Interview Beginner News Startup Quiz

Users

Career

Apply Job Internship

Pricing

Understanding Reflection in Java: Accessing Class Information at Runtime

ICSM Computer 627 24 Apr 2025

Ask by ICSM Computer

Updated 24 Apr 2025

1 Answers

ICSM Computer 24 Apr 2025

Reflection in Java is a effective function that lets in programs to look at and manage classes, methods, fields, and constructors at runtime — although their names are not known until execution.

1. What Can You Do With Reflection?

Using reflection, you can:

Get information about a class (name, methods, fields, constructors, etc.)
Instantiate objects dynamically
Invoke methods dynamically
Access or modify fields, even private ones

2. How to Use Reflection

Reflection is available in the java.lang.reflect package. You typically start by getting the Class object of the target class.

Class<?> clazz = Class.forName("com.example.MyClass");

Or, if you have the object:

Class<?> clazz = myObject.getClass();

3. Examples of Using Reflection

a. Get Class Information

public class Demo {
    public int num;
    private String text;

    public void sayHello() {
        System.out.println("Hello");
    }
}

public class ReflectionInfo {
    public static void main(String[] args) {
        Class<?> clazz = Demo.class;

        System.out.println("Class Name: " + clazz.getName());

        System.out.println("\nFields:");
        for (Field field : clazz.getDeclaredFields()) {
            System.out.println(field.getName());
        }

        System.out.println("\nMethods:");
        for (Method method : clazz.getDeclaredMethods()) {
            System.out.println(method.getName());
        }
    }
}

b. Accessing and Modifying Fields

import java.lang.reflect.Field;

public class ReflectionFieldAccess {
    public static void main(String[] args) throws Exception {
        Demo demo = new Demo();
        Class<?> clazz = demo.getClass();

        Field field = clazz.getDeclaredField("text");
        field.setAccessible(true); // Allow access to private field

        field.set(demo, "Reflection Rocks!");
        System.out.println("Value of text: " + field.get(demo));
    }
}

c. Invoking Methods Dynamically

import java.lang.reflect.Method;

public class ReflectionMethodInvoke {
    public static void main(String[] args) throws Exception {
        Demo demo = new Demo();
        Class<?> clazz = demo.getClass();

        Method method = clazz.getDeclaredMethod("sayHello");
        method.invoke(demo); // calls demo.sayHello()
    }
}

d. Creating Object Using Constructor

import java.lang.reflect.Constructor;

public class ReflectionConstructor {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Demo.class;
        Constructor<?> constructor = clazz.getConstructor();
        Object obj = constructor.newInstance();

        System.out.println("Object created: " + obj);
    }
}

4. Important Notes

Reflection breaks encapsulation and should be used carefully.
It can lead to performance overhead.
It's frequently used in frameworks like Spring, Hibernate, and JUnit.
Reflection can get admission to private participants, but you need to apply setAccessible(actual).

Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md

interview