A summary of Java Reflection Learning (Basic article)

Class is the core class in the reflection API, and he is located in Java.lang.Class

Lists some of the commonly used methods.

-GetName (): Get the full name of the class

-GetFields (): Gets the properties of the public type of the class

-Getdeclaredfields (): Get all the properties of the class

-GetMethods (): Method for obtaining the public type of a class

-Getdeclaredmethods (): Get all methods of class

-GetMethod (String name, class[] parametertypes): Gets the specific method of the class (the name parameter specifies the method name, and the Parametertypes parameter specifies the method parameter type)

-GetConstructors (): How to get the public type of a class

-GetConstructor (class[] parametertypes): Gets the specific construction method of the class (the Parametertypes parameter specifies the parameter type of the constructor method)

-Newinstance (): Creates an object of this class from the constructor of the class without parameters

If you want to use reflection, there are 2 key parts

1. Get the Class object

2. Obtaining an Object instance

These two sections are described below:

1. How to obtain a class object

3 common ways to get a class object that corresponds to one of the classes or objects

A) Use the static method of class Forname:

class.forname ("java.lang.String");

b) Use the class's. class syntax :

String.class;

c) Use the GetClass () method of the object (the method in the Java.lang.Object Class):

String s = "AA";

class<?> clazz = S.getclass ();

2. How to obtain an object instance

We all know that getting an object instance is going to be a new one, which is actually the construction method of the calling object

There are two different types of calling constructor method parameters:

A) Call the constructor without parameters:

1. Call the Newinstance () method of the class object:

class<?> ClassType = Classclass.forname ("java.lang.String");

Object object = Classtpye. newinstance ();

2. Call the Newinstance () method of the constructor object of the class object and pass an empty class object array as the parameter:

class<?> ClassType = Classclass.forname ("java.lang.String");

Constructor cons = Classtype.getconstructor (new class[]{});

Object object =cons.newinstance (new object[]{});

b) Call the constructor with parameters:

1. Call the Newinstance () method of the Class object's constructor object, passing a variable-length class object array as a parameter, this example passes string,int two parameters:

class<?> ClassType = Classclass.forname ("java.lang.String");

Constructor cons = Classtype.getconstructor (new Class[]{string.class, int.class});

Object Object =cons.newinstance (new object[]{"Hello", 3});

Here is a small demo, because it is too simple to paste the code here

This demo simple implementation of the above described some of the use of reflection, as a review to consolidate:

[Java]View Plaincopy print?

2. Class Person {
6. private Long ID;
8. private int age;
10. private String name;
14. Public Person () {
18. }
22. Public person (String name, int age) {
24. this.name = name;
26. this.age = age;
28. }
32. @Override
34. Public String toString () {
38. return "Name=" +getname () +"age=" +getage () +"id=" +getid ();
40. }
44. public Long GetId () {
46. return ID;
48. }
52. public void SetId (long id) {
54. this.id = ID;
56. }
60. public int getage () {
62. return age;
64. }
68. public void Setage (int.) {
70. this.age = age;
72. }
76. Public String GetName () {
78. return name;
80. }
84. public void SetName (String name) {
86. this.name = name;
88. }
92. }

A very simple custom class, two constructor methods, and some get,set methods, and a rewrite of the ToString

The following is the code in the main method of invoking reflection, mainly is to call the person's parameter construction method with the reflection method to assign a value to Age,name, call SetID to assign the ID, and finally call the ToString method to print the result

[Java]View Plaincopy print?

2. Public static void Main (string[] args) throws Exception {
6. //Get the class object for person classes
8. class<?> ClassType = class.forname ("person");
12. //Call the two parameter construction method of the person class to build the object
14. Constructor Constructor = classtype.getconstructor (new class[]{string.   class, int.class});
16. Object object = Constructor.newinstance (new object[]{"Dean",25});
20. //Get SetID method
22. Method setId = Classtype.getmethod ("SetId", new class[]{long.   class});
26. //Call the SetID method to set the ID
28. Setid.invoke (object, new object[]{10});
32. //Call ToString Output result
34. Method toString = Classtype.getmethod ("toString", new class[]{});
36. String result = (string) Tostring.invoke (object, new object[]{});
38. SYSTEM.OUT.PRINTLN (result);
40. }

The output is: Name=dean age=25 id=10

Recently watching the reflection of the video and materials, the purpose of writing this blog is to learn a summary of it.

In succession, I would like to update some of the deeper reflective knowledge I have summed up, I hope you can support

A summary of Java Reflection Learning (Basic article)