标签：ram unit interface 详细信息 actual run 列表 构造方法 配置
反射
1.在运行期间，动态获取某个类的详细信息
2.在运行期间，动态创建任意类型的对象
3.在运行期间，动态的为对象赋值
4.在运行期间，动态的调用对象的任意方法
package test04; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import org.junit.Test; /* 反射 1.在运行期间，动态获取某个类的详细信息 2.在运行期间，动态创建任意类型的对象 3.在运行期间，动态的为对象赋值 4.在运行期间，动态的调用对象的任意方法 1.在运行期间，动态获取某个类的详细信息 步骤： 1.获取某个对象的Class对象 2.使用Class对象和java.lang.reflect包下面的其他类型的API Class中的API: 1.包：package getPackage() 2.类的修饰符：int getModifiers() 3.类名：getName() 4.父类：getSuperclass() 5.接口：getInterfaces() 6.属性：Field[] getFields():该类及其所有超类的公共字段 Field[] getFields(String name) Field[] getDeclaredFields() 该类的字段 Field[] getDeclaredFields(String name) 7.构造器：Construct<?> getConstructors() Construct<?> getConstructors(Class<?> ... parameterTypes) Construct<?> getDeclaredConstructors() Construct<?> getDeclaredConstructors(Class<?> ... parameterTypes) 8.方法：Method[] getMethods() Method[] getMethods(String name,Class<?> ... parameterTypes) Method[] getDeclaredMethods() Method[] getDeclaredMethods(String name,Class<?> ... parameterTypes) java.lang.reflect包 （1）package类型 包名：getName() (2)Modifier类型 (3)Field类型 【修饰符】 数据类型 属性名 set/get值 属性名：getName() 属性修饰符：getModifiers() 属性类型：getType() (4)Constructor类型 【修饰符】 构造器名（形参列表）{} 构造器名：getName() 构造器修饰符：getModifiers() 构造器形参列表：getParameterTypes() (5)Method类型 【修饰符】返回值类型 方法名 （【形参列表】） throws 异常列表{} 被调用invoke 方法名：getName() 方法修饰符：getModifiers() 方法形参列表：getParameterTypes() 方法返回值类型：getReturnType() */ public class test02 { @Test public void test2() throws Exception{ //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.获取包信息 Package pk = c.getPackage(); System.out.println(pk.getName());//AtStudent //3.获取Class的修饰符 int mod = c.getModifiers(); System.out.println(mod);//1 System.out.println(Modifier.toString(mod));//public //4.获取类名 System.out.println(c.getName());//AtStudent.Student //5.获取父类 Class<?> parent = c.getSuperclass(); System.out.println(parent.getName());//java.util.Date //6.获取父接口 Class<?>[] interfaces = c.getInterfaces(); for(Class<?> inter:interfaces) { System.out.println(inter);//interface java.io.Serializable } System.out.println(); //7.获取属性 Field[] alldeclaredFields = c.getDeclaredFields(); for(Field field:alldeclaredFields) { //属性名 System.out.println(field.getName()); //属性的修饰符 int fmod = field.getModifiers(); System.out.println(Modifier.toString(fmod));//public //属性的数据类型 Class<?> ftype = field.getType(); System.out.println(ftype.getName()); } System.out.println(); //8.获取构造器 Constructor<?>[] alldeclaredConstructors = c.getDeclaredConstructors(); for (Constructor<?> constructor:alldeclaredConstructors ) { //构造器名 System.out.println(constructor.getName()); //构造器的修饰符 int cmod = constructor.getModifiers(); System.out.println(Modifier.toString(cmod)); //构造器的形参列表 Class<?>[] parameterTypes = constructor.getParameterTypes(); for(Class<?> pt: parameterTypes) { System.out.println(pt.getName()); } } //9.方法 Method[] alldeclaredMethods = c.getDeclaredMethods(); for (Method method:alldeclaredMethods) { //方法名 System.out.println(method.getName()); //方法的修饰符 int cmod = method.getModifiers(); System.out.println(Modifier.toString(cmod)); //方法返回值类型 Class<?> returnType = method.getReturnType(); System.out.println(returnType); //方法的形参列表 Class<?>[] parameterTypes = method.getParameterTypes(); for(Class<?> pt: parameterTypes) { System.out.println(pt.getName()); } } }
package test04; import java.lang.reflect.Constructor; import org.junit.Test; /* 反射 在运行期间，动态创建任意类型的对象 1.Class对象.newInstance()创建实例对象 前提：类必须有无参构造方法 （1）获取Class对象 （2）Class对象.newInstance() 2.构造器创建实例对象 （1）获取Class对象 （2）获取构造器对象，获取其中一个 Construct<?> getConstructors(Class<?> ... parameterTypes) parameterTypes：形参列表 （3）用构造器创建对象 java.lang.reflect.Constructor类型中newInstance(initargs) initargs：实参类表 */ public class test03 { @Test public void test2() throws Exception { //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.获取构造器对象 Constructor<?> constructor = c.getDeclaredConstructor(String.class,int.class); //3.用构造器创建对象 Object obj = constructor.newInstance("zhang",20); System.out.println(obj);//Student [name=zhang, age=20] } @Test public void test1() throws Exception { //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.创建Student对象 Object obj = c.newInstance(); System.out.println(obj);//Student [name=zhang, age=0] } }
package test04; import java.lang.reflect.Field; import org.junit.Test; /* 反射 在运行期间，动态的为对象赋值或者获取属性值 1.获取Class对象 2.获取Field属性对象 3.创建Student对象 4.为属性赋值 set() 5.获取属性的值get() */ public class test04 { @Test public void test1() throws Exception { //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.获取Field属性对象 Field name_field = c.getDeclaredField("name"); name_field.setAccessible(true); //3.创建Student对象 Object stu = c.newInstance(); //4.为属性赋值 name_field.set(stu, "wang"); //5.获取属性的值 Object object = name_field.get(stu); System.out.println(object); } }
package test04; import java.lang.reflect.Method; import org.junit.Test; /* 反射 在运行期间，动态的调用对象的任意方法 1.获取Class对象 2.获取Method对象 c.getDeclaredMethod(name, parameterTypes) name:方法名 parameterTypes：形参列表 3.创建Student对象：如果是静态方法，不需要创建实例对象 c.newInstance() 4.调用方法 invoke:如果是静态方法，实例对象可以是Null */ public class test05 { //静态方法 @Test public void test2() throws Exception { //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.获取Method对象 Method method = c.getDeclaredMethod("test", int.class); //3.调用方法 method.invoke(null, 10); } //非静态方法 @Test public void test1() throws Exception { //1.获取Class对象 Class<?> c= Class.forName("AtStudent.Student"); //2.获取Method对象 Method method = c.getDeclaredMethod("setName", String.class); //3.创建Student对象 Object stu = c.newInstance(); //4.调用方法 method.invoke(stu, "zhao"); System.out.println(stu); } }
package test04; //获取父类泛型 import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; public class test06 { public static void main(String[] args) { //1.Son对象 Class<?> c=Son.class; //2.获取父类 Class<?> parent = c.getSuperclass(); System.out.println(parent);//class test04.Father //2.获取泛型父类 Type parent_type = c.getGenericSuperclass(); System.out.println(parent_type);//test04.Father<java.lang.String, java.lang.Integer> ParameterizedType p =(ParameterizedType) parent_type; System.out.println(p);//test04.Father<java.lang.String, java.lang.Integer> //获取泛型实参 Type[] types=p.getActualTypeArguments(); for(Type type:types) { System.out.println(type); } } } abstract class Father<T,U>{ } class Son extends Father<String,Integer>{ }
package test04; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; /* 获取注解信息 1.申明 2.使用 3.读取 */ public class test07 { public static void main(String[] args) { //读取Myclass上面的注解 //1.获取Myclass的class对象 Class<?> c= Myclass.class; //2.获取Myclass上面的注解 MyAnntation my= c.getAnnotation(MyAnntation.class); //3.获取注解的配置参数的值 String value = my.value(); System.out.println(value);//zhang san } } //使用注释 @MyAnntation("zhang san") class Myclass{ } //申明注解信息 @Retention(RetentionPolicy.RUNTIME) //使注解能有效到代码运行时 @interface MyAnntation{ String value(); }
标签：ram unit interface 详细信息 actual run 列表 构造方法 配置
原文地址：https://www.cnblogs.com/hapyygril/p/13037639.html
