Reflection in Java: How to Look Inside Code and Control It

Reflection and Introspection in Java: Magic Accessible to Everyone

Imagine you are a programmer writing code that can analyze itself at runtime. Sounds like science fiction? In Java, this is a reality, and it's called reflection.

When I first encountered reflection in Java, I was amazed by its power. Imagine: you can load a class by name, discover all its methods and fields, and even invoke a private method that the class author wanted to hide. It's like getting a key to every door in a building. Cool? Absolutely. Dangerous? Also yes.

In this article, we'll break down what reflection and introspection in Java are, how they work, and — most importantly — how to use them wisely. There will be plenty of code, examples, and practical tips. Let's go!

What is Reflection in Java in Simple Terms

Reflection in Java is a mechanism that allows a program to obtain information about classes, interfaces, methods, and fields at runtime. Moreover, using reflection, you can create objects, invoke methods, and modify field values, even if they are private.

And what is introspection in Java? It is a part of reflection that is specifically responsible for "peeking": obtaining information about a class's structure without modifying it. Introspection is analysis; reflection is analysis + action.

At the core of everything is the java.lang.Class class. It's like a "passport" for any object. When the JVM loads a class, it creates a Class object that stores all the metadata.

How to Get a Class Object: Three Ways

Before working magic with reflection, you need to get a Class object. Here are three main ways:

// 1. Via .class\nClass<String> stringClass = String.class;\n\n// 2. Via getClass() on an object\nString hello = "Hello";\nClass<? extends String> helloClass = hello.getClass();\n\n// 3. Via Class.forName() (most flexible)\ntry {\n    Class<?> dynamicClass = Class.forName("java.util.ArrayList");\n} catch (ClassNotFoundException e) {\n    e.printStackTrace();\n}\n

The third method is especially useful when the class name is unknown at compile time — for example, it comes from a configuration file or a database.

Introspection: Looking Inside a Class

Let's write a small class and see what we can learn about it using introspection in Java.

import java.lang.reflect.*;\n\npublic class ReflectionDemo {\n    \n    private String secret = "This is a secret!";\n    public int number = 42;\n    \n    public void publicMethod() {\n        System.out.println("Public method");\n    }\n    \n    private void privateMethod() {\n        System.out.println("Private method");\n    }\n    \n    public static void main(String[] args) throws Exception {\n        // Get the Class object\n        Class<?> demoClass = Class.forName("ReflectionDemo");\n        \n        System.out.println("=== Class Name ===");\n        System.out.println(demoClass.getName());\n        \n        System.out.println("\\n=== All Fields ===");\n        Field[] fields = demoClass.getDeclaredFields();\n        for (Field field : fields) {\n            System.out.println(field.getName() + " : " + field.getType().getSimpleName());\n        }\n        \n        System.out.println("\\n=== All Methods ===");\n        Method[] methods = demoClass.getDeclaredMethods();\n        for (Method method : methods) {\n            System.out.println(method.getName() + "()");\n        }\n        \n        System.out.println("\\n=== Constructors ===");\n        Constructor<?>[] constructors = demoClass.getDeclaredConstructors();\n        for (Constructor<?> constructor : constructors) {\n            System.out.println(constructor);\n        }\n    }\n}\n

Running this