目录
注解
什么是注解
package com.study.annotation; //何为注释 public class Test01 extends Object{ //@Override 重写的注释 @Override public String toString() { return super.toString(); } }
内置注解
package com.study.annotation; import java.util.ArrayList; import java.util.List; public class Test01 extends Object{ //@Override 重写的注释 @Override public String toString() { return super.toString(); } //Deprecated 不推荐程序员使用,但是可以使用,或者存在更好的方法! @Deprecated public static void test(){ System.out.println("Deprecated"); } @SuppressWarnings("all") public static void test02(){ List list = new ArrayList(); System.out.println("SuppressWarnings"); } public static void main(String[] args) { test(); } }
元注解
package com.study.annotation; import java.lang.annotation.*; public class Test02 { public void test(){ } } //定义一个注解 //Target 表示我们的注解可以用在那些地方 @Target(value = {ElementType.METHOD,ElementType.TYPE}) //Retention 表示我们的注解在什么地方有效 //runtime>class>source @Retention(value = RetentionPolicy.RUNTIME) //Documented 表示是否将我们的注解生成JavaDoc中 @Documented //Inherited 子类可以继承父类的注解 @Inherited @interface MyAnnotation{ }
自定义注解
package com.study.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; //自定义注解 public class Test03 { //注解可以显示赋值,如果没有默认值,我们就必须给注解赋值~ @MyAnnotation2(age=18,name="张三") public void Test(){} } @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @interface MyAnnotation2{ //注解的参数:参数类型 + 参数名(); String name() default ""; int age(); int id() default -1; String[] schools() default {"清华大学","北京大学"}; }
静态语言VS动态语言
反射
什么是反射
反射机制
package com.study.reflection; public class Test02 { public static void main(String[] args) throws ClassNotFoundException { //通过反射机制获取类的class对象 Class c1 = Class.forName("com.study.reflection.User"); System.out.println(c1); Class c2 = Class.forName("com.study.reflection.User"); Class c3 = Class.forName("com.study.reflection.User"); Class c4 = Class.forName("com.study.reflection.User"); //一个类在内存中只有一个Class对象 //一个类被加载后,类的整个结构就会被封装在Class对象中。 System.out.println(c2.hashCode()); System.out.println(c3.hashCode()); System.out.println(c4.hashCode()); } } //实体类:pojo entity class User{ private String name; private int id; private int age; public User() { } public User(String name, int id, int age) { this.name = name; this.id = id; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}'; } }
运行结果:
class com.study.reflection.User 460141958 460141958 460141958
反射的优缺点
Class类
Class类的常用方法
获取Class类的实例
package com.study.reflection; //测试class类的创建方式有哪些 public class Test03 { public static void main(String[] args) throws ClassNotFoundException { Person perosn = new Student(); System.out.println("这个人是"+perosn.name); //方式一:通过对象获得 Class c1 = perosn.getClass(); System.out.println(c1.hashCode()); //方式二:forname获得 Class c2 = Class.forName("com.study.reflection.Student"); System.out.println(c2.hashCode()); //方式三:通过类名.class获得 Class c3 = Student.class; System.out.println(c3.hashCode()); //方式四:基本内置类型中包装类都有一个Type属性 Class c4 = Integer.TYPE; System.out.println(c4); //获得父类类型 Class c5 = c1.getSuperclass(); System.out.println(c5); } } class Person{ String name; public Person() { } public Person(String name) { this.name = name; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + '}'; } } class Student extends Person{ public Student() { this.name = "学生"; } } class Teacher extends Person{ public Teacher() { this.name = "老师"; } }
运行结果:
这个人是学生 460141958 460141958 460141958 int class com.study.reflection.Person
Class对象
package com.study.reflection; import java.lang.annotation.ElementType; public class Test04 { public static void main(String[] args) { Class c1 = Object.class;//类 Class c2 = Comparable.class;//接口 Class c3 = String[].class;//一维数组 Class c4 = String[][].class;//二维数组 Class c5 = Override.class;//注解 Class c6 = ElementType.class;//枚举 Class c7 = Integer.class;//基本数据类型 Class c8 = void.class;//void Class c9 = Class.class;//Class System.out.println(c1); System.out.println(c2); System.out.println(c3); System.out.println(c4); System.out.println(c5); System.out.println(c6); System.out.println(c7); System.out.println(c8); System.out.println(c9); //只要元素类型与维度一致,就是同一Class int[] a = new int[10]; int[] b = new int[100]; System.out.println(a.getClass().hashCode()); System.out.println(b.getClass().hashCode()); } }
运行结果:
class java.lang.Object interface java.lang.Comparable class [Ljava.lang.String; class [[Ljava.lang.String; interface java.lang.Override class java.lang.annotation.ElementType class java.lang.Integer void class java.lang.Class 460141958 460141958
内存分析
package com.study.reflection; public class Test05 { public static void main(String[] args) { A a = new A(); System.out.println(A.m); /* * 1。加载到内存,会产生一个类对应的Classdx * 2.链接,链接结束后m=0 * 3.初始化 * <clinit>(){ * System.out.println("A类静态代码块初始化"); m = 300; m = 100; * } * */ } } class A{ static { System.out.println("A类静态代码块初始化"); m = 300; } static int m =100; public A() { System.out.println("A类的无参构造初始化"); } }
运行结果:
A类静态代码块初始化 A类的无参构造初始化 100
类初始化
package com.study.reflection; public class Test06 { static { System.out.println("Main类被加载"); } public static void main(String[] args) throws ClassNotFoundException { //1.主动引用 //Son son = new Son(); //反射也会产生主动引用 //Class.forName("com.study.reflection.Son"); //不会产生类的引用的方法 System.out.println(Son.m);//m为Father类的变量 //Son[] sons = new Son[5]; //System.out.println(Son.N); } } class Father{ static int m =100; static { System.out.println("父类被加载"); m = 300; } } class Son extends Father{ static { System.out.println("子类被加载"); n = 300; } static int n =100; static final int N = 1; }
运行结果:
Main类被加载 父类被加载 300
类加载器
package com.study.reflection; public class Test07 { public static void main(String[] args) throws ClassNotFoundException { //获取系统类的加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); System.out.println(systemClassLoader); //获取系统类加载器的父类加载器-->扩展类加载器 ClassLoader parent = systemClassLoader.getParent(); System.out.println(parent); //获取拓展类加载器的父类加载器-->根加载器(C/C++) ClassLoader parent1 = parent.getParent(); System.out.println(parent1); //测试当前类是哪个类加载器加载的 ClassLoader classLoader = Class.forName("com.study.reflection.Test07").getClassLoader(); System.out.println(classLoader); //测试JDK内置的类是谁加载的 ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader(); System.out.println(classLoader1); //如何获取系统类加载器可以加载的路径 System.out.println(System.getProperty("java.class.path")); /* * D:\JDK8\jdk1.8\jre\lib\charsets.jar; * D:\JDK8\jdk1.8\jre\lib\deploy.jar; * D:\JDK8\jdk1.8\jre\lib\ext\access-bridge-64.jar; * D:\JDK8\jdk1.8\jre\lib\ext\cldrdata.jar; * D:\JDK8\jdk1.8\jre\lib\ext\dnsns.jar; * D:\JDK8\jdk1.8\jre\lib\ext\jaccess.jar; * D:\JDK8\jdk1.8\jre\lib\ext\jfxrt.jar; * D:\JDK8\jdk1.8\jre\lib\ext\localedata.jar; * D:\JDK8\jdk1.8\jre\lib\ext\nashorn.jar; * D:\JDK8\jdk1.8\jre\lib\ext\sunec.jar; * D:\JDK8\jdk1.8\jre\lib\ext\sunjce_provider.jar; * D:\JDK8\jdk1.8\jre\lib\ext\sunmscapi.jar; * D:\JDK8\jdk1.8\jre\lib\ext\sunpkcs11.jar; * D:\JDK8\jdk1.8\jre\lib\ext\zipfs.jar; * D:\JDK8\jdk1.8\jre\lib\javaws.jar; * D:\JDK8\jdk1.8\jre\lib\jce.jar; * D:\JDK8\jdk1.8\jre\lib\jfr.jar; * D:\JDK8\jdk1.8\jre\lib\jfxswt.jar; * D:\JDK8\jdk1.8\jre\lib\jsse.jar; * D:\JDK8\jdk1.8\jre\lib\management-agent.jar; * D:\JDK8\jdk1.8\jre\lib\plugin.jar; * D:\JDK8\jdk1.8\jre\lib\resources.jar; * D:\JDK8\jdk1.8\jre\lib\rt.jar; * D:\OnlineStudy\Annotation\out\production\Annotation; * D:\IDEA\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar * */ //双亲委派机制 //如:java.path.String--> } }
类的完整结构
package com.study.reflection; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class Test08 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException { Class c1 = Class.forName("com.study.reflection.User"); //User user = new User(); //c1 = user.getClass(); //获得类的名字 System.out.println(c1.getName());//获得包名 + 类名 System.out.println(c1.getSimpleName());//获得类名 //获得类的属性 System.out.println("==============================="); Field[] fields = c1.getFields();//只能找到public属性 fields = c1.getDeclaredFields();//找到全部属性 for (Field field : fields) { System.out.println(field); } //获得指定属性的值 Field name = c1.getDeclaredField("name"); System.out.println(name); //获得类的方法 System.out.println("==============================="); Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法 for (Method method : methods) { System.out.println("正常的:" + method); } methods = c1.getDeclaredMethods();//获得本类的所有方法 for (Method method : methods) { System.out.println("getDeclaredMethods:" + method); } //获得指定方法 Method getName = c1.getMethod("getName", null); Method setName = c1.getMethod("setName", String.class); System.out.println(getName); System.out.println(setName); //获得指定的构造器 System.out.println("==============================="); Constructor[] constructors = c1.getConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } constructors = c1.getDeclaredConstructors(); for (Constructor constructor : constructors) { System.out.println("#"+constructor); } //获得指定的构造器 Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class); System.out.println("指定:" + declaredConstructor); } }
Class对象
package com.study.reflection; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class Test09 { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { //获得Class对象 Class c1 = Class.forName("com.study.reflection.User"); //构造一个对象 User user = (User) c1.newInstance();//本质是调用了类的无参构造器 System.out.println(user); //通过构造器创建对象 Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class); User user2 = (User)constructor.newInstance("张三",001,18); System.out.println(user2); //通过反射调用普通方法 User user3 = (User) c1.newInstance(); //通过反射获取一个方法 Method setName = c1.getDeclaredMethod("setName", String.class); //invoke:激活的意思 //{对象,”方法的值“} setName.invoke(user3,"张三"); System.out.println(user3.getName()); //通过反射操作属性 User user4 = (User)c1.newInstance(); Field name = c1.getDeclaredField("name"); //不能直接操作私有属性,我们需要关闭程序的安全检测,属性或者方法的name.setAccessible(true); name.setAccessible(true); name.set(user4,"李四"); System.out.println(user4); } }
setAccessible(true)方法
性能对比分析
package com.study.reflection; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; import java.lang.reflect.Method; public class Test10 { public static void test01(){ User user = new User(); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1_000_000_000; i++) { user.getName(); } long endTime = System.currentTimeMillis(); System.out.println("普通方法执行10亿次:" + (endTime - startTime) + "ms"); } //反射方法调用 public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1.getDeclaredMethod("getName",null); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1_000_000_000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("反射方法执行10亿次:" + (endTime - startTime) + "ms"); } //反射方式调用 关闭检测 public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1.getDeclaredMethod("getName",null); getName.setAccessible(true); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1_000_000_000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("关闭检测执行10亿次:" + (endTime - startTime) + "ms"); } public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException { test01(); test02(); test03(); } }
运行结果:
普通方法执行10亿次:3ms 反射方法执行10亿次:1644ms 关闭检测执行10亿次:1091ms
操作泛型
package com.study.reflection; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.List; import java.util.Map; public class Test11 { public void test01(Map<String,User>map, List<User>list){ System.out.println("test01"); } public Map<String ,User> test02(){ System.out.println("test02"); return null; } public static void main(String[] args) throws NoSuchMethodException { Method method = Test11.class.getMethod("test01", Map.class, List.class); Type[] genericParameterTypes = method.getGenericParameterTypes(); for (Type genericParameterType : genericParameterTypes) { System.out.println("#" + genericParameterType); if (genericParameterType instanceof ParameterizedType){ Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } method = Test11.class.getMethod("test02", null); Type genericReturnType = method.getGenericReturnType(); if (genericReturnType instanceof ParameterizedType){ Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } }
运行结果:
#java.util.Map<java.lang.String, com.study.reflection.User> class java.lang.String class com.study.reflection.User #java.util.List<com.study.reflection.User> class com.study.reflection.User class java.lang.String
获取注解信息
package com.study.reflection; import java.lang.annotation.*; import java.lang.reflect.Field; public class Test12 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { Class c1 = Class.forName("com.study.reflection.Student2"); //通过反射获得注解 Annotation[] annotations = c1.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(annotation); } //获得注解value的值 TableStudy tableStudy = (TableStudy)c1.getAnnotation(TableStudy.class); String value = tableStudy.value(); System.out.println(value); //获取类的注定注解 Field f = c1.getDeclaredField("name"); FieldStudy annotation = f.getAnnotation(FieldStudy.class); System.out.println(annotation.columname()); System.out.println(annotation.type()); System.out.println(annotation.length()); } } @TableStudy("db_student") class Student2{ @FieldStudy(columname = "db_id",type = "int",length = 10) private int id; @FieldStudy(columname = "db_age",type = "int",length = 10) private int age; @FieldStudy(columname = "db_name",type = "varchar",length = 3) private String name; public Student2() { } public Student2(int id, int age, String name) { this.id = id; this.age = age; this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Student2{" + "id=" + id + ", age=" + age + ", name='" + name + '\'' + '}'; } } //类名的注解 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface TableStudy{ String value(); } //属性的注解 @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface FieldStudy{ String columname(); String type(); int length(); }
运行结果:
@com.study.reflection.TableStudy(value=db_student) db_student db_name varchar 3