Java reflection allows checking and manipulating components such as classes, methods, fields at runtime, and supports dynamic creation of instances, calling methods, and accessing fields, especially for frameworks such as Spring and Hibernate. Its core functions include: 1. Check the class structure; 2. Dynamically create instances; 3. Access private or protected members; 4. Call methods under unknown types. Practical applications include dependency injection, ORM mapping, testing tools and serialization libraries. Examples of usage include loading classes, creating instances, getting and calling methods. Notes include performance overhead, security restrictions, code obfuscation issues and loss of compile-time checks. Therefore, reflection should be used with caution and is suitable for building a common framework rather than everyday business logic.

Reflection in Java is a powerful feature that lets you inspect and manipulate classes, methods, fields, and other components of a Java program at runtime. This means you can do things like create instances of a class, call its methods, or access its fields without knowing about them at compile time.

It's especially useful when working with libraries or frameworks where the code needs to interact with user-defined classes it wasn't originally built with — think Spring, Hibernate, or even JUnit.

What Can You Do With Reflection?

Java reflection gives you the ability to:

• Inspect a class's structure (like its methods, fields, constructors)
• Create an instance of a class dynamically
• Access private or protected fields and methods
• Invoke methods on objects without knowing their types ahead of time

For example, if you have a class name as a string ( "com.example.MyClass" ), you can load it, instantiate it, and call its methods — all during runtime.

This flexibility comes at a cost though. Reflection is slower than direct method calls, and it can break encapsulation by accessing private members, which might lead to fragile code if used carelessly.

When Is Reflection Actually Used?

You might not use reflection directly every day, but chances are you've benefited from it through frameworks. Here are some real-world cases:

• Dependency Injection Frameworks like Spring use reflection to wire up beans and management dependencies.
• ORM Libraries such as Hibernate rely on reflection to map database rows to Java objects.
• Testing Tools like JUnit use it to find and run test methods automatically.
• Serialization Libraries (eg, Jackson) use reflection to read object fields and convert them into JSON.

So while you might not reach for reflection often in your own application code, understanding how it works helps you better understand how these tools operate under the hood.

How to Use Reflection (A Quick Example)

Let's say you want to create an instance of a class and call one of its methods, all using reflection.

Here's a simple way to do that:

1. Get the Class object using the class name.
2. Create a new instance using newInstance() (or a constructor).
3. Get the method you want to call using getMethod() .
4. Invoke the method on the object.

 Class<?> clazz = Class.forName("com.example.MyClass");
Object obj = clazz.newInstance();
Method method = clazz.getMethod("doSomething");
method.invoke(obj);

Note: This is simplified. In practice, you'll also need to handle exceptions like ClassNotFoundException , InstantiationException , and IllegalAccessException .

Also, if the method requires parameters, you'll need to pass them in the invoke() call. And if the method is private, you'll need to call setAccessible(true) on the method object first.

Things to Watch Out For

Reflection isn't something you should use everywhere. A few gotchas include:

• Performance Overhead : Invoking methods via reflection is significantly slower than direct calls.
• Security Restrictions : Some environments restrict reflective access, especially in modular applications (Java 9).
• Code Obfuscation Issues : If you're using tools like ProGuard, they might rename or remove elements reflection depends on.
• Loss of Compile-Time Checks : Since reflection bypasses normal compilation checks, errors might only appear at runtime.

Use reflection when necessary — like when building generic frameworks or dealing with unknown classes — but avoid overusing it in regular app logic.

That's basically what reflection in Java is and why it matters. It's a tool that gives you a lot of runtime flexibility, but with trade-offs in performance and safety.

The above is the detailed content of What is reflection in Java?. For more information, please follow other related articles on the PHP Chinese website!