Dieser Artikel bietet Ihnen eine kurze Einführung in die Java-Reflexion (Codebeispiele). Ich hoffe, dass er für Sie hilfreich ist.
1. Eine kurze Einführung in Class
Die Class-Klasse repräsentiert die Klassen und Schnittstellen in der laufenden Java-Anwendung. Eine Aufzählung ist eine Klasse, eine Annotation ist eine Schnittstelle, und jedes Array gehört auch zu einer Klasse, die als Klassenobjekt dargestellt wird, das von allen Arrays mit demselben Elementtyp und derselben Dimensionalität gemeinsam genutzt wird. Die primitiven Java-Typen (boolean, byte, char, short, int, long, float und double) und das Schlüsselwort void werden ebenfalls als Klassenobjekte dargestellt.
Auszug aus der chinesischen Version von jdk1.8. Möglicherweise verstehen Sie es zunächst nicht. Jetzt werde ich es Satz für Satz erklären.
Der erste Satz: Nachdem eine Klasse geladen wurde, erstellt die JVM ein Klassenobjekt der entsprechenden Klasse im Speicher.
Der zweite Satz: Objekte desselben Typs und Arrays mit derselben Dimension (unabhängig von der Länge) teilen sich dasselbe Klassenobjekt im Speicher.
Der dritte Satz: Die oben genannten primitiven Typen haben auch ein Klassenobjekt im Speicher
package com.dingyu;
import org.junit.Test;
/**
* Class的简单使用方法
*
* @author 70241
*
*/
public class ClassDemo {
@Test
public void classTest1() {
try {
Class class1 = Class.forName("com.dingyu.User");// 第一种获取Class对象的方法
User user = new User();
Class class2 = user.getClass();// 第二种获取Class对象的方法
Class class3=User.class;//第三种获取Class对象的方法
System.out.println("接下来判断到底同一类的不同对象的Class对象是不是同一个:"
+ (class1.hashCode() == class2.hashCode()&&class1.hashCode() == class3.hashCode()));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@Test
public void classTest2() {
String[] s1 = new String[10];
String[] s2 = new String[30];
String[][] s3 = new String[3][30];
System.out.println(s1.getClass().hashCode()==s2.getClass().hashCode());
System.out.println(s1.getClass().hashCode()==s3.getClass().hashCode());
}
}
package com.dingyu;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
/**
* Class的简单用法
*
* @author dingyu
*
*/
public class ClassDemo02 {
@Test
public void usingClass() throws Exception {
Class userClass = Class.forName("com.dingyu.User");
// 获得类名
System.out.println(userClass.getName());// 获得全类名
System.out.println(userClass.getSimpleName());// 获得类名
// 获得属性
Field[] fields = userClass.getDeclaredFields();// 获得所有的属性
for (Field field : fields) {
System.out.println(field.getName());
}
System.out.println(userClass.getDeclaredField("id").getName());// 获得指定的属性
// 获得方法
Method[] methods = userClass.getDeclaredMethods();// 获得所有的方法
for (Method method : methods) {
System.out.println(method.getName());
}
Method method = userClass.getDeclaredMethod("setId", int.class);// 获得指定的方法，前面方法名，后面方法的参数
System.out.println(method.getName());
// 获得构造器
Constructor[] constructors = userClass.getDeclaredConstructors();
System.out.println(constructors.length);
Constructor constructor = userClass.getDeclaredConstructor(int.class, String.class, int.class);// 获得指定的构造器，需要指定构造的参数
System.out.println(constructor.getName());
// 获得注解
Annotation[] annotations = userClass.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 指定注解名
MyAnnotation annotation = (MyAnnotation)userClass.getDeclaredAnnotation(MyAnnotation.class);
System.out.println(annotation);
}
}package com.dingyu;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
/**
* 使用反射动态的调用构造器，方法，修改属性
* @author 70241
*
*/
public class ClassDemo03 {
@Test
@SuppressWarnings("all")
public void usingClass() throws Exception {
Class class1 = Class.forName("com.dingyu.User");
//使用反射去调用构造器
User user1 = (User) class1.newInstance();//调用的是无参的
Constructor constructor = class1.getDeclaredConstructor(int.class,String.class,int.class);//获得有参的构造器
User user2 = (User) constructor.newInstance(04,"dingyu",20);//动态生成对象
//使用反射去调用方法
Method methodSetId = class1.getDeclaredMethod("setId",int.class);
methodSetId.invoke(user1, 02);//执行user1中的setId，后面是给的参数
System.out.println(user1.getId());
//使用反射去修改属性的值
Field field = class1.getDeclaredField("age");
field.setAccessible(true);//因为age是私有的，加上这句就表示这个属性不需要做安全检查
field.set(user1, 20);
System.out.println(field.get(user1));
System.out.println(user1.getAge());
}
}package com.dingyu;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
/**
* 反射获得带泛型的参数或返回值里泛型的的类型
* @author dingyu
*
*/
public class ClassDemo04 {
public void test01(Map<Integer, String> map, String s) {
}
public Map<Integer, String> test02() {
return null;
}
public static void main(String[] args) throws Exception {
//参数中带泛型的
Method method = ClassDemo04.class.getDeclaredMethod("test01", Map.class, String.class);
Type[] types = method.getGenericParameterTypes();// 返回一个 Type对象的数组， Type以声明顺序表示由该对象表示的可执行文件的形式参数类型
// 打印这些参数的类型
for (Type type : types) {
System.out.println(type.getTypeName());
if (type instanceof ParameterizedType) {// 如果是泛型的参数
Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();// 获得泛型的的类型
for (Type type2 : actualTypeArguments) {
System.out.println(type2.getTypeName());
}
}
}
//返回值中带泛型的
Method method02 = ClassDemo04.class.getDeclaredMethod("test02");
Type type = method02.getGenericReturnType();// 返回的类型
// 打印这些返回的类型
System.out.println(type.getTypeName());
if (type instanceof ParameterizedType) {// 如果是泛型的参数
Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();// 获得泛型的的类型
for (Type type2 : actualTypeArguments) {
System.out.println(type2.getTypeName());
}
}
}
}
Das obige ist der detaillierte Inhalt vonEine kurze Einführung in die Java-Reflexion (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
