Detailed usage of Java Reflect

Keywords: Java

Catalog

I. What is Reflection
II. Basic Class of Reflection
- 2.1 Class class overview
- 2.2 Three Ways of Obtaining Class Class Objects
3. Reflection-constructor
- 3.1 getDeclaredConstructor(Class<?>...parameterTypes)
- 3.2 getDeclaredConstructors()
Reflection-member variables
- 4.1 getDeclaredField(String name)
- 4.3 getDeclaredFields()
V. Reflection-Membership Method
VI. Summary

I. What is Reflection

In the running state, for any class, all its attributes and methods can be known, and for any object, any method and attributes can be invoked. This ability to dynamically obtain information and invoke methods is called the reflection mechanism of Java language. Most frameworks use reflection mechanism to understand reflection. The method of use is very important.

A class usually contains attributes, methods, constructors and so on. Java usually has objects in existing classes. It calls various attributes and methods through objects, while Java reflection obtains information about its classes and calls related methods of its classes through existing objects.

II. Basic Class of Reflection

2.1 Class class overview

We know that in the Java world, everything is an object. In fact, the class itself is an object, and any class is an instance object of the Class class.

//Define a SuperHero class
public class SuperHero {}

As defined above, SuperHero classes are classes and objects.

Object: SuperHero class is an instance of Class class, Class class is the class type of SuperHero, so it is an object.

Class: Created as a class, SuperHero itself can call SuperHero ironMan = new SuperHero () to be instantiated. IronMan is the entity created, so it is also a class.

Class class is very special. It represents the class type of a class and can not be inherited. There is only one Class object for each class. Class class has no common constructor. Instead, Class objects are built automatically by the Java virtual machine because classes are loaded, and are represented as Class objects by calling the defineClass method in the class loader, the original Java types (boolean, byte, char, short, int, long, float and double), and the keyword void.

//Class source code, final modifier can not be inherited, constructor is private, can not be instantiated manually
public final class Class<T> {
    private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }
}

public static void main(String[] args) {
    try {
        Class clazz1 = Class.forName("java.lang.Integer");
        Class clazz2 = Class.forName("java.lang.Integer");
        System.out.println(clazz1 == clazz2);
        System.out.println(int.class);
        System.out.println(void.class);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

The results are as follows:

true
int
void

2.2 Three Ways of Obtaining Class Class Objects

Define a class first

package reflectdemo;
import java.io.Serializable;

/**
 * Superheroes
 */
public class SuperHero implements Serializable {
    
    public static final String ADDRESS = "earth";
    
    private String id;

    private String name;

    private Integer age;

    private String skill;

    public SuperHero() {
    }

    public SuperHero(String id, String name, Integer age, String skill) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.skill = skill;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
    
    public void print(){
        System.out.println("Superhero Movie:" + this.name);
    }
}

2.2.1 Getting Class from Objects

public static void main(String[] args) {
    SuperHero ironMan = new SuperHero("1","Iron Man",35, "War armor");
    Class clazz = ironMan.getClass();
    System.out.println(clazz.getName());
}

Output results:

reflectdemo.SuperHero

2.2.2 Get Class by Class

public static void main(String[] args) {
    Class clazz = SuperHero.getClass();
    System.out.println(clazz.getName());
}

Output results:

reflectdemo.SuperHero

2.2.3 Input Class Path to Get Class

public static void main(String[] args) {
    try {
        Class clazz = Class.forName("reflectdemo.SuperHero");
        System.out.println(clazz.getName());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

Output results:

reflectdemo.SuperHero

There are three ways to create:

The first way is that the object already exists, and all operations can be done directly through the object.

The second way requires import to introduce classes, which is not the usual way.

The third way is to get the relevant information of the class only by passing in the path of the class, which is the most commonly used way.

2.2.4 Common methods for obtaining class information

public static void main(String[] args) {
    try {
        Class clazz = Class.forName("reflectdemo.SuperHero");
        //Get the class name (with path)
        System.out.println(clazz.getName());
        //Get the class name (without paths)
        System.out.println(clazz.getSimpleName());
        //Get the package in question
        System.out.println(clazz.getPackage());

        //Create objects through Class
        SuperHero hero = (SuperHero)clazz.newInstance();
        
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

Output results:

reflectdemo.SuperHero
SuperHero
package reflectdemo

Let me explain in advance that two methods in Class have the same functions. If one of them has the word Declared, which means all declared variables, methods, constructors, etc. in the class, and the corresponding method without the word Declared, it means that only public member variables and methods work, and the following is not repeated. Description, below is only a description of the method with the word Declared.