1: 类的初始化
1 package Reflection; 2 3 import java.sql.Struct; 4 5 /** 6 * author liulei 7 * data 5.22 8 * since 1.8 9 * version 1.0 10 * Description 类的初始化 11 */ 12 public class Test04 { 13 public static void main(String[] args) throws ClassNotFoundException { 14 //1主动引用 15 Son s = new Son();//new 一个实例 16 Class.forName("Reflection.Son");//反射会主动引用 17 //2 不会产生引用 18 System.out.println(Son.b);//子类引用父类的方法 19 Son[] s1 = new Son[5];//通过数组定义类引用 20 } 21 } 22 class Father{ 23 static int b = 2; 24 static { 25 System.out.println("父类被加载"); 26 } 27 } 28 class Son extends Father{ 29 static { 30 System.out.println("子类被加载"); 31 } 32 static int m = 100; 33 static final int n = 1; 34 }
2：类加载器的作用
1 package Reflection; 2 3 /** 4 * author liulei 5 * data 5.22 6 * since 1.8 7 * version 1.0 8 * Description 三种类加载器 9 */ 10 public class Test5 { 11 12 //双亲委派机制：java.lang.String-->,多重检测，当自己写的类和跟类(rt.jar)相同时，自己写的类无效 13 public static void main(String[] args) throws ClassNotFoundException { 14 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();//系统类加载器 15 System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2 16 ClassLoader parent = systemClassLoader.getParent();//扩展类加载器（是系统类加器的子集或父亲） 17 System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@1b6d3586 18 ClassLoader parent1 = parent.getParent();//跟加载器（扩展类加载器的子集或父亲） 19 System.out.println(parent1);//null,因为不可访问所以为null 20 //测试当前类是那个加载器加载的 21 ClassLoader classLoader = Class.forName("Reflection.Test5").getClassLoader();//sun.misc.Launcher$AppClassLoader@18b4aac2 22 System.out.println(classLoader); 23 //获取jdk内置的类是谁加载的 24 ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader(); 25 System.out.println(classLoader1);//null 26 //如何获得系统类加载器可以加载的路径 27 System.out.println(System.getProperty("java.class.path")); 28 /* 29 D:\Eclipse\JDK\jre\lib\charsets.jar; 30 D:\Eclipse\JDK\jre\lib\deploy.jar; 31 D:\Eclipse\JDK\jre\lib\ext\access-bridge-64.jar; 32 D:\Eclipse\JDK\jre\lib\ext\cldrdata.jar; 33 D:\Eclipse\JDK\jre\lib\ext\dnsns.jar; 34 D:\Eclipse\JDK\jre\lib\ext\jaccess.jar; 35 D:\Eclipse\JDK\jre\lib\ext\jfxrt.jar; 36 D:\Eclipse\JDK\jre\lib\ext\localedata.jar; 37 D:\Eclipse\JDK\jre\lib\ext\nashorn.jar; 38 D:\Eclipse\JDK\jre\lib\ext\sunec.jar; 39 D:\Eclipse\JDK\jre\lib\ext\sunjce_provider.jar; 40 D:\Eclipse\JDK\jre\lib\ext\sunmscapi.jar; 41 D:\Eclipse\JDK\jre\lib\ext\sunpkcs11.jar; 42 D:\Eclipse\JDK\jre\lib\ext\zipfs.jar; 43 D:\Eclipse\JDK\jre\lib\javaws.jar; 44 D:\Eclipse\JDK\jre\lib\jce.jar; 45 D:\Eclipse\JDK\jre\lib\jfr.jar; 46 D:\Eclipse\JDK\jre\lib\jfxswt.jar; 47 D:\Eclipse\JDK\jre\lib\jsse.jar; 48 D:\Eclipse\JDK\jre\lib\management-agent.jar; 49 D:\Eclipse\JDK\jre\lib\plugin.jar; 50 D:\Eclipse\JDK\jre\lib\resources.jar; 51 D:\Eclipse\JDK\jre\lib\rt.jar; //java核心库 52 D:\Code\IDEA\Stage01\Demo03\out\production\Demo03;//自己的目录 53 D:\IDEA\IntelliJ IDEA Community Edition 2020.1.1\lib\idea_rt.jar 54 55 */ 56 } 57 }
3：如何获取类的完整结构
package Reflection; import javax.naming.Name; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * author liulei * data * since 1.8 * version 1.0 * Description 获取运行时类的完整结构 */ public class Test6 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException { Class aClass = Class.forName("Reflection.user"); System.out.println(aClass.getName());//报名+类名 System.out.println(aClass.getSimpleName());//类名 Field[] fields = aClass.getFields();//获取public的字段 System.out.println("===================================字段"); Field[] declaredFields = aClass.getDeclaredFields();//可以获取私有字段 for(Field field:fields){ System.out.println(field);//无输出 } for (Field field1:declaredFields){ System.out.println(field1);//有输出 /* java.lang.String Reflection.user.name int Reflection.user.id int Reflection.user.age */ } //获得指定属性的值 Field name = aClass.getDeclaredField("name"); //获取方法 System.out.println("===============================方法"); Method[] declaredMethods = aClass.getMethods();//获取本类和父类的所有方法 for(Method m:declaredMethods){ System.out.println(m); } Method[] declaredMethods1 = aClass.getDeclaredMethods();//获取本类的所有方法 for(Method m1:declaredMethods1){ System.out.println(m1); } //获取指定属性的方法 Method getName = aClass.getDeclaredMethod("getName", null); Method setName = aClass.getDeclaredMethod("setName", String.class); System.out.println(getName); System.out.println(setName); //获取构造器 System.out.println("=======================================构造器"); Constructor[] constructors = aClass.getConstructors(); for (Constructor c:constructors){ System.out.println(c); } Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class, int.class); System.out.println("指定"+declaredConstructor); } } class user{ private String name; private int id; private int age; public user(String name, int id, int age) { this.name = name; this.id = id; this.age = age; } public user() { } public String getName() { return name; } public int getId() { return id; } public int getAge() { return age; } public void setName(String name) { this.name = name; } public void setId(int id) { this.id = id; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "user{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}'; } }
4：利用Class对象创建类的对象操作属性，方法，泛型，注解等
1 package Reflection; 2 3 import java.lang.reflect.Constructor; 4 import java.lang.reflect.Field; 5 import java.lang.reflect.InvocationTargetException; 6 import java.lang.reflect.Method; 7 8 /** 9 * author liulei 10 * data 5.22 11 * since 1.8 12 * version 1.0 13 * Description 用Class创建对象操作类方法和属性 14 */ 15 public class Test7 { 16 public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { 17 Class<?> aClass = Class.forName("Reflection.user"); 18 user instance =(user)aClass.newInstance();//本质是调用不参构造器创建对象 19 System.out.println(instance); 20 //通过构造器创建对象 21 Constructor constructor = aClass.getDeclaredConstructor(String.class,int.class,int.class); 22 user haha = (user)constructor.newInstance("haha", 12, 12); 23 System.out.println(haha); 24 //通过对象获取一个方法 25 Method setName = aClass.getDeclaredMethod("setName", String.class); 26 setName.invoke(instance,"我的名字");//激活该方法 27 System.out.println(instance.getName()); 28 //获取对象一个属性 29 Field name = aClass.getDeclaredField("name"); 30 name.setAccessible(true);//不能直接操作私有属性，需要改代码设置关闭安全监测 31 name.set(instance,"我的名字"); 32 System.out.println(instance.getName()); 33 34 35 } 36 }
使用反射是低效率的，
1 package Reflection; 2 3 import java.lang.reflect.InvocationTargetException; 4 import java.lang.reflect.Method; 5 6 7 /** 8 * author liulei 9 * data 5.22 10 * since 1.8 11 * version 1.0 12 * Description 效率分析 13 */ 14 public class Test8 { 15 //普通方法调用 16 public static void demo01(){ 17 user u = new user(); 18 long startTime = System.currentTimeMillis(); 19 for (int i = 0; i <= 100000000; i++){ 20 u.getName(); 21 } 22 long endtime = System.currentTimeMillis(); 23 System.out.println(endtime-startTime); 24 } 25 //反射方法调用 26 public static void demo02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { 27 user u = new user(); 28 Class aClass = Class.forName("Reflection.user"); 29 Method getName = aClass.getDeclaredMethod("getName"); 30 long startTime = System.currentTimeMillis(); 31 for (int i = 0; i <= 100000000; i++){ 32 getName.invoke(u,null); 33 } 34 long endtime = System.currentTimeMillis(); 35 System.out.println(endtime-startTime); 36 } 37 //反射方法调用,关闭监测 38 public static void demo03() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { 39 user u = new user(); 40 Class aClass = Class.forName("Reflection.user"); 41 Method getName = aClass.getDeclaredMethod("getName"); 42 getName.setAccessible(true); 43 long startTime = System.currentTimeMillis(); 44 for (int i = 0; i <= 100000000; i++){ 45 getName.invoke(u,null); 46 } 47 long endtime = System.currentTimeMillis(); 48 System.out.println(endtime-startTime); 49 50 } 51 52 public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException { 53 demo01();//3 54 demo02();//286 55 demo03();//155 56 //所以反射应用耗时较长，尽量不适用不必要的反射，同时需要关闭监测时尽量关闭监测可以加快时间 57 } 58 59 }
通过反射获取操作泛型
1 package Reflection; 2 3 import java.lang.reflect.Method; 4 import java.lang.reflect.ParameterizedType; 5 import java.lang.reflect.Type; 6 import java.util.List; 7 import java.util.Map; 8 9 /** 10 * author liulei 11 * data 12 * since 1.8 13 * version 1.0 14 * Description 通过反射获取泛型 15 */ 16 public class Test9 { 17 public void test01(Map<String,user> map, List<user> list){ 18 System.out.println("test01"); 19 } 20 public Map<String,user> test02(){ 21 System.out.println("test02"); 22 return null; 23 } 24 25 public static void main(String[] args) throws NoSuchMethodException { 26 Method test01 = Test9.class.getMethod("test01", Map.class, List.class); 27 Type[] genericParameterType = test01.getGenericParameterTypes(); 28 for(Type gpt:genericParameterType){ 29 System.out.println("gpt"+gpt); 30 if(gpt instanceof ParameterizedType){ 31 Type[] actualTypeArguments = ((ParameterizedType) gpt).getActualTypeArguments(); 32 for (Type p:actualTypeArguments){ 33 System.out.println(actualTypeArguments); 34 } 35 } 36 } 37 Method test02 = Test9.class.getMethod("test02", null); 38 Type genericParameterTypess = test02.getGenericReturnType(); 39 if(genericParameterTypess instanceof ParameterizedType){ 40 Type[] actualTypeArguments = ((ParameterizedType) genericParameterTypess).getActualTypeArguments(); 41 for (Type act:actualTypeArguments){ 42 System.out.println(actualTypeArguments); 43 } 44 } 45 } 46 }
1 package Reflection; 2 3 import java.lang.annotation.*; 4 import java.lang.reflect.Field; 5 6 /** 7 * author liulei 8 * data 5.22 9 * since 1.8 10 * version 1.0 11 * Description 反射获取注解 12 */ 13 public class Test10 { 14 public static void main(String[] args) throws Exception { 15 Class aClass = Class.forName("Reflection.student2"); 16 Annotation[] annotations = aClass.getAnnotations(); 17 for (Annotation a:annotations){ 18 System.out.println(a);//属性是私有的，所以没有输出属性的注解 19 } 20 //获得注解的value的值 21 table t = (table) aClass.getAnnotation(table.class); 22 String value = t.value(); 23 System.out.println(value); 24 //获得类指定的注解 25 Field name = aClass.getDeclaredField("name"); 26 zidingyi annotation = name.getAnnotation(zidingyi.class); 27 System.out.println(annotation.columnName()); 28 System.out.println(annotation.type()); 29 System.out.println(annotation.length()); 30 } 31 } 32 @table("db_student") 33 class student2{ 34 @zidingyi(columnName = "db_id",type = "int",length = 10) 35 private int id; 36 @zidingyi(columnName = "db_id",type = "int",length = 10) 37 private int age; 38 @zidingyi(columnName = "db_id",type = "int",length = 10) 39 private String name; 40 41 public student2() { 42 } 43 44 public student2(int id, int age, String name) { 45 this.id = id; 46 this.age = age; 47 this.name = name; 48 } 49 50 public void setId(int id) { 51 this.id = id; 52 } 53 54 public void setAge(int age) { 55 this.age = age; 56 } 57 58 public void setName(String name) { 59 this.name = name; 60 } 61 62 public int getId() { 63 return id; 64 } 65 66 public int getAge() { 67 return age; 68 } 69 70 public String getName() { 71 return name; 72 } 73 74 @Override 75 public String toString() { 76 return "student2{" + 77 "id=" + id + 78 ", age=" + age + 79 ", name='" + name + '\'' + 80 '}'; 81 } 82 } 83 @Target(ElementType.FIELD) 84 @Retention(RetentionPolicy.RUNTIME) 85 @interface zidingyi{ 86 String columnName(); 87 String type(); 88 int length(); 89 } 90 @Target(ElementType.TYPE) 91 @Retention(RetentionPolicy.RUNTIME) 92 @interface table{ 93 String value(); 94 }
Class.getAnnotations() 获取所有的注解，包括自己声明的以及继承的
Class.getAnnotation(Class< A > annotationClass) 获取指定的注解，该注解可以是自己声明的，也可以是继承的
Class.getDeclaredAnnotations() 获取自己声明的注解