7.2.4 - Using Reflection to Inspect a Class
Enroll to start learning
You’ve not yet enrolled in this course. Please enroll for free to listen to audio lessons, classroom podcasts and take practice test.
Interactive Audio Lesson
Listen to a student-teacher conversation explaining the topic in a relatable way.
Introduction to Reflection
🔒 Unlock Audio Lesson
Sign up and enroll to listen to this audio lesson
Today, we will discuss Java's Reflection API, which allows us to inspect and manipulate classes at runtime. To start, can anyone share what they know about reflection?
I think it's used to load classes dynamically?
Exactly, Student_1! Reflection enables us to load classes, retrieve methods, and even access private fields. It’s like using a magic mirror to see inside our code!
What do you mean by 'inspect and manipulate'?
Great question, Student_2! Inspecting means checking properties of a class, such as its methods and fields. Manipulating can involve calling those methods or changing field values at runtime. Let's dive into the main classes we use for reflection: `Class`, `Method`, and `Field`.
Obtaining Class Objects
🔒 Unlock Audio Lesson
Sign up and enroll to listen to this audio lesson
Now, how do we actually obtain a class object in Java? We have a few methods, such as using `Class.forName(String className)`.
Are there other ways?
Yes, there are! We can also use `getClass()` on an instance of the object or use the class literal like `MyClass.class`. Each of these methods serves different scenarios.
Can you give us an example?
Sure! If we have `MyClass obj = new MyClass();`, using `obj.getClass()` will return the `Class` object representing `MyClass`. This is handy for dynamic code execution.
Inspecting Methods and Fields
🔒 Unlock Audio Lesson
Sign up and enroll to listen to this audio lesson
Let’s move on to inspecting properties. We can retrieve fields and methods using `clazz.getDeclaredFields()` and `clazz.getDeclaredMethods()`. Who remembers what those methods return?
They return arrays of Field and Method objects?
Correct! And each object allows us to access metadata and invoke functionalities on those members. Let’s write a quick code snippet together!
What about accessing private fields? Can we do that?
Yes, but with caution! We use `field.setAccessible(true)` to bypass access checks. However, it’s essential to manage this carefully to avoid breaking encapsulation.
Using Reflection with Annotations
🔒 Unlock Audio Lesson
Sign up and enroll to listen to this audio lesson
Lastly, let’s talk about how reflection works with annotations. Can anyone tell me why this is significant?
It probably helps in frameworks that rely on metadata?
Exactly! By utilizing reflection, we can read annotation values at runtime, which is crucial for frameworks like Spring and JUnit. Let’s take the `Processor` class as an example and see how annotations enhance functionality.
So, we can execute methods based on annotations?
Yes, Student_4! That flexibility allows for dynamic method invocation based on the configuration provided through annotations.
Introduction & Overview
Read summaries of the section's main ideas at different levels of detail.
Quick Overview
Standard
The section elaborates on how the Reflection API allows developers to dynamically analyze and manipulate classes, methods, and fields in Java, showcasing practical examples of accessing class members and utilizing annotations.
Detailed
In this section, we explore the Java Reflection API, a powerful feature that promotes flexibility by enabling runtime inspection and manipulation of class members, including fields and methods. We cover various key classes in the java.lang.reflect package, including Class, Method, Field, and Constructor, and how to obtain class objects using different methods like Class.forName, instance method calls, and class literals. Additionally, practical examples illustrate how to retrieve class properties and how to access private members using reflection. By the end of this section, we understand the implications of using reflection in terms of performance and security. We also touch on the relationship between reflection and annotations, emphasizing how they collectively enhance dynamic programming in Java.
Youtube Videos
Audio Book
Dive deep into the subject with an immersive audiobook experience.
Class Definition and Basic Reflection
Chapter 1 of 5
🔒 Unlock Audio Chapter
Sign up and enroll to access the full audio experience
Chapter Content
public class Sample {
private int id;
public String name;
public void display() {
System.out.println("Display");
}
}
Detailed Explanation
In this chunk, we define a simple Java class called 'Sample' with three members: a private integer 'id', a public string 'name', and a public method 'display()'. This class serves as a base for demonstrating the power of reflection, which allows us to inspect the properties and methods of this class at runtime, even if they are private.
Examples & Analogies
Think of this class as an employee in a company. The 'id' number is a confidential record (private), while the 'name' is displayed publicly (public). Just like how you can ask a manager about an employee's job responsibilities (methods) without directly accessing their personal files (private fields).
Using Reflection to Access Class Information
Chapter 2 of 5
🔒 Unlock Audio Chapter
Sign up and enroll to access the full audio experience
Chapter Content
Class clazz = Sample.class;
System.out.println("Fields:");
for (Field field : clazz.getDeclaredFields()) {
System.out.println(field.getName());
}
System.out.println("Methods:");
for (Method method : clazz.getDeclaredMethods()) {
System.out.println(method.getName());
}
Detailed Explanation
Here, we use reflection to obtain information about the 'Sample' class. We get a Class object for 'Sample' and then use getDeclaredFields() to list all its fields and getDeclaredMethods() to list all its methods. The output would show us 'id', 'name', and 'display' as the fields and methods of the class, giving us the ability to inspect data types and behaviors within the class.
Examples & Analogies
Imagine you are a librarian (using reflection) who wants to know about a specific book (class). You can look inside to see what chapters (fields) it has and what actions (methods) you can perform with it, even if you can't open the book to read every detail.
Creating Objects Using Reflection
Chapter 3 of 5
🔒 Unlock Audio Chapter
Sign up and enroll to access the full audio experience
Chapter Content
Class clazz = Class.forName("Sample");
Object obj = clazz.getDeclaredConstructor().newInstance();
Detailed Explanation
In this chunk, we demonstrate how to create an instance of the 'Sample' class dynamically at runtime using reflection. We use Class.forName() to get the Class object, and then getDeclaredConstructor().newInstance() to create a new object of that class. This shows the power of reflection by allowing object creation without knowing the class directly at compile time.
Examples & Analogies
Consider this like a chef who can prepare any dish (create instances) without having the recipe book (class definition) at hand. The chef can choose what to cook (create an object) based on the ingredients available (class name) and prepare it right there in the kitchen (runtime).
Accessing Private Members with Reflection
Chapter 4 of 5
🔒 Unlock Audio Chapter
Sign up and enroll to access the full audio experience
Chapter Content
Field field = clazz.getDeclaredField("id");
field.setAccessible(true);
field.set(obj, 101);
System.out.println(field.get(obj));
Detailed Explanation
This chunk discusses how reflection can be used to access private members of a class. By utilizing getDeclaredField(), we can access the private field 'id' from the 'Sample' class. We then use setAccessible(true) to bypass access checks and change the value of 'id' to 101, before printing the new value. This ability should be used cautiously as it breaks encapsulation principles.
Examples & Analogies
Imagine you have a safe (the private field) where a secret (id) is stored. Normally, you can’t open it without permission. However, if you had the right tools (reflection), you could bypass the lock (setAccessible) and change the contents of the safe without the owner's knowledge, which may not always be the right thing to do.
Reflection with Annotations
Chapter 5 of 5
🔒 Unlock Audio Chapter
Sign up and enroll to access the full audio experience
Chapter Content
public class Processor {
@MyAnnotation(value = "run")
public void execute() {
System.out.println("Executing...");
}
}
Processor:
Class<?> clazz = Processor.class;
for (Method method : clazz.getDeclaredMethods()) {
if (method.isAnnotationPresent(MyAnnotation.class)) {
MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
System.out.println("Annotation value: " + anno.value());
method.invoke(clazz.getDeclaredConstructor().newInstance());
}
}
Detailed Explanation
In this final chunk, we show how reflection can be used to process annotations. The 'Processor' class contains a method 'execute' annotated with '@MyAnnotation'. Using reflection, we check for the presence of this annotation, retrieve its value, and then invoke the method. This illustrates how annotations can drive execution behavior in a program dynamically.
Examples & Analogies
Think of annotations as special instructions or notes left by a programmer. It's like a chef (the method) who has a note (the annotation) that tells them to follow a specific recipe step in a cooking competition. Using reflection is like the judges looking at those notes to see what the chef is supposed to do next and ensure they follow the rules.
Key Concepts
-
Reflection API: Allows runtime inspection and manipulation of class elements.
-
Obtaining Class Objects: Class objects can be acquired through various methods.
-
Inspecting Class Members: Classes, methods, and fields can be enumerated using reflection.
-
Accessing Private Members: Private fields can be accessed by setting them to be accessible.
-
Dynamic Invocation: Annotations can influence method execution at runtime.
Examples & Applications
Using Class.forName('com.example.MyClass') to load a class dynamically.
Iterating through fields with For (Field field : clazz.getDeclaredFields()) to print field names.
Invoking methods at runtime by checking for annotations and dynamically executing them.
Memory Aids
Interactive tools to help you remember key concepts
Rhymes
Reflection gives a peek inside, to see class members, not to hide.
Stories
Imagine a magician who can make any class appear and reveal its secrets. That's what reflection does in Java!
Memory Tools
Remember: R-I-M (Reflection - Inspect - Manipulate) to recall the core functions of the Reflection API.
Acronyms
E.R.A (Explore, Retrieve, Access) to remember the primary actions achievable through reflection.
Flash Cards
Glossary
- Reflection API
A feature in Java that allows inspection and manipulation of classes at runtime.
- Field
Represents a variable in a class, which can be accessed and manipulated using reflection.
- Method
Represents a method in a class, which can be invoked dynamically using reflection.
- Class
Represents a class in Java, and its instance can be obtained using reflection.
- setAccessible
A method to bypass access checks for private members, allowing manipulation of private fields.
Reference links
Supplementary resources to enhance your learning experience.