How to define and use Java reflection

Definition

The ability to dynamically obtain and manipulate elements such as classes, methods, properties, etc. during the running of a Java program is called Java reflection. It allows us to obtain information about a class and operate on it while the program is running, which greatly expands the flexibility and scalability of the Java language.

In Java, each class has a corresponding Class object, and reflection uses this Class object to obtain and operate class information.

Get the Class object

In Java, there are three ways to get the Class object:

1.1 Get the Class object through the class name

This is the most common One way is to use the Class.forName() method to obtain the Class object. For example:

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

1.2 Obtain the Class object through the object

You can obtain the Class object to which it belongs through the getClass() method of the object. For example:

MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();

1.3 Obtain Class object through class literal constant

Use class literal constant to obtain Class object, for example:

Class<?> clazz = MyClass.class;

Get class information

By obtaining the Class object, we can obtain various information about the class, such as class name, inherited class, implemented interface, constructor, methods and fields, etc. The following is an example of obtaining the fields of a class.

2.1 Get all fields

You can get all public modified fields through the getFields() method of the Class object, for example:

Field[] fields = clazz.getFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

2.2 Get the specified fields

You can get the public modified fields with the specified name through the getField() method of the Class object, for example:

Field field = clazz.getField("name");
System.out.println(field.getName());

2.3 Get all declared fields

Can get it through the getDeclaredFields() method of the Class object All declared fields, including fields modified by public, protected, and private, for example:

Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

2.4 Get the specified declared field

You can obtain the declaration with the specified name through the getDeclaredField() method of the Class object Fields, including fields modified by public, protected, and private, for example:

Field field = clazz.getDeclaredField("name");
System.out.println(field.getName());

Operation classes and objects

Once we obtain the class information, we can use reflection to operate classes and objects, such as Create objects, call methods and access properties. The following is an example of creating objects and accessing properties.

3.1 Create an object

You can create an object through the newInstance() method of the Class object, for example:

MyClass obj = (MyClass) clazz.newInstance();

3.2 Access properties

You can use reflection Access the properties of an object, including getting and setting property values. For example:

Field field = clazz.getDeclaredField("name");
field.setAccessible(true);
field.set(obj, "张三");
String name = (String) field.get(obj);

The above code first obtains the name attribute of the class and sets it to be accessible, then sets the attribute value to "Zhang San" through reflection, and finally obtains the attribute value and assigns it to the name variable.

Reflection application scenarios

Reflection is widely used in Java. Common scenarios include:

4.1 Dependency injection

Dependency injection is a A method to dynamically inject dependencies into a class through reflection. For example, dependency injection in the Spring framework is implemented through reflection.

4.2 Configuration file parsing

In Java, configuration files such as XML and JSON can be parsed through reflection, and the data in the configuration file can be converted into Java objects.

4.3 Dynamic proxy

Dynamic proxy is a method of generating proxy classes through reflection. Dynamic proxies allow proxy objects to be generated at runtime to enhance or intercept target objects.

Advantages and Disadvantages of Reflection

Java's flexibility and scalability can be achieved by dynamically obtaining and manipulating class information at runtime. This is the advantage of reflection. Reflection can realize some functions that cannot be achieved by traditional methods, such as dynamic proxy, dependency injection, etc.

Due to the need to dynamically obtain and operate class information at runtime, the performance of reflection operations is usually worse than direct operation of classes. This is a shortcoming of reflection. Using reflection reduces code readability because code that calls an object's methods or accesses properties is usually simpler and clearer than code that uses reflection.

The above is the detailed content of How to define and use Java reflection. For more information, please follow other related articles on the PHP Chinese website!