注解与反射机制

阳光穿透心脏的1/2处 2024-04-20 11:20 133阅读 0赞

注解与反射机制

一、注解

1.什么是注解

java.annotation包
Annotation是从JDK1.5开始引入的新技术，注解即可以对程序员解释又可以对程序解释

2.注解与注释的区别

注释：对程序员解释代码信息

注解：对程序和程序员解释代码信息

3.注解的所用

不是程序本身，可以对程序作出解释（与注释(comment)类似）

可以被其他程序（编译器）读取

4.注解的格式

注解是以“@注释名”在代码中存在的，还可以添加一些参数

例如：@SuppressWarnings(value=“unchecked”)

5.注解的应用

可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制实现对这些数据的访问

6.内置注解

@Overrlde：定义在java.lang.Override中，此注解只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明

@Deprecated：定义在java.lang.Deprecated中.此注解可以用于修饰方法，属性，类。表示不鼓励使用这样的元素.通常是因为它很危险或者存在更好的选择

@SuppressWarnings：镇压警告，定义在java.lang.SuppressWarnings中用来抑制编译时的警告信息，与前两个注释有所不同.你需要添加参数才能正确使用。这些参数都是已经定义好了的.我们选择性的使用就好了
@SuppressWarnings(“all”)抑制所有类型的警告信息
@SuppressWarnings(“unchecked”)抑制单类型的警告信息
@SuppressWarnings(value={“unchecked”,“deprecation”})抑制多类型的警告信息

7.元注解

元注解的作用：负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明

这些类型和它们所支持的类在java.lang.annotation包中可以找到

（@Target，@Retention，@Documented，@Inherited )

@Target：用于描述注解的使用范围(即:被描述的注解可以用在什么地方）

@Retention：表示需要要在什么级别保存该注择信息，用于描述注解的生命周期

(SOURCE < CLASS <RUNTIME)

@Document：说明该注解将被包含在javadoc中

@lnherited：说明子类可以继承父类中的该注解

  1. @MyAnnotation02
  2. public class Test01<@MyAnnotation02 T> {
  5.     @MyAnnotation02
  6.     public String name;
  8.     @MyAnnotation02
  9.     public Test01() {
  11.     }
  13.     @MyAnnotation01
  14.     @MyAnnotation02
  15.     @MyAnnotation03("aaa")
  16.     @MyAnnotation04
  17.     @MyAnnotation05(name = "aaa")
  18.     @MyAnnotation06(names = {
  19.     "aaa","bbb"})
  20.     @MyAnnotation07(names={
  21.     "aaa","bbb"},username="撕裂的忧伤")
  22.     public void method(String str){
  25.         @MyAnnotation02
  26.         int i = 100;
  27.         System.out.println(i);
  28.     }
  29. }
  31. import java.lang.annotation.ElementType;
  32. import java.lang.annotation.Retention;
  33. import java.lang.annotation.RetentionPolicy;
  34. import java.lang.annotation.Target;
  35. /**
  36.  * 该注解只能在方法上使用，并且没有参数
  37.  */
  39. @Target(ElementType.METHOD)
  40. @Retention(RetentionPolicy.RUNTIME)
  41. public @interface MyAnnotation01 {
  44. }
  46. import static java.lang.annotation.ElementType.*;
  47. import java.lang.annotation.Retention;
  48. import java.lang.annotation.RetentionPolicy;
  49. import java.lang.annotation.Target;
  50. /**
  51.  * 该注解可以在方法、类、构造方法、属性、局部变量、泛型上使用，并且没有参数
  52.  */
  54. @Target({
  55.     METHOD,TYPE,CONSTRUCTOR,FIELD,LOCAL_VARIABLE,TYPE_PARAMETER})
  56. @Retention(RetentionPolicy.RUNTIME)
  57. public @interface MyAnnotation02 {
  60. }
  62. import static java.lang.annotation.ElementType.*;
  63. import java.lang.annotation.Retention;
  64. import java.lang.annotation.RetentionPolicy;
  65. import java.lang.annotation.Target;
  67. /**
  68.  * 该注解可以在方法上使用，并且有一个参数
  69.  */
  70. @Target(METHOD)
  71. @Retention(RetentionPolicy.RUNTIME)
  72. public @interface MyAnnotation03 {
  75.     String value();
  76. }
  78. import static java.lang.annotation.ElementType.*;
  79. import java.lang.annotation.Retention;
  80. import java.lang.annotation.RetentionPolicy;
  81. import java.lang.annotation.Target;
  83. /**
  84.  * 该注解可以在方法上使用，并且有一个参数
  85.  */
  86. @Target(METHOD)
  87. @Retention(RetentionPolicy.RUNTIME)
  88. public @interface MyAnnotation04 {
  91.     String value() default "abc";//设置默认值
  92. }
  94. import static java.lang.annotation.ElementType.*;
  95. import java.lang.annotation.Retention;
  96. import java.lang.annotation.RetentionPolicy;
  97. import java.lang.annotation.Target;
  99. /**
  100.  * 该注解可以在方法上使用，并且有一个参数
  101.  */
  102. @Target(METHOD)
  103. @Retention(RetentionPolicy.RUNTIME)
  104. public @interface MyAnnotation05 {
  107.     String name();
  108. }
  110. import static java.lang.annotation.ElementType.*;
  111. import java.lang.annotation.Retention;
  112. import java.lang.annotation.RetentionPolicy;
  113. import java.lang.annotation.Target;
  115. /**
  116.  * 该注解可以在方法上使用，并且有一个参数
  117.  */
  118. @Target(METHOD)
  119. @Retention(RetentionPolicy.RUNTIME)
  120. public @interface MyAnnotation06 {
  123.     String[] names();
  124. }
  126. import static java.lang.annotation.ElementType.*;
  127. import java.lang.annotation.Retention;
  128. import java.lang.annotation.RetentionPolicy;
  129. import java.lang.annotation.Target;
  131. /**
  132.  * 该注解可以在方法上使用，并且有一个参数
  133.  */
  134. @Target(METHOD)
  135. @Retention(RetentionPolicy.RUNTIME)
  136. public @interface MyAnnotation07 {
  139.     String[] names();
  140.     String username();
  141.     String password() default "00000000";
  142. }

8.自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

分析：

@interface用来声明一个注解，格式：public @interface注解名{定义内容}

其中的每一个方法实际上是声明了一个配置参数.

方法的名称就是参数的名称.

返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）

可以通过default来声明参数的默认值

如果只有一个参数成员，一般参数名为value()

注解元素必須要有值，我们定义注解元素时，经常使用空字符串.0作为默认值

  1. import java.util.ArrayList;
  3. public class test01 {
  6.     //重写的注解
  7.     @Override
  8.     public boolean equals(Object obj) {
  10.         return super.equals(obj);
  11.     }
  13.     //过时的注解
  14.     @Deprecated
  15.     public void method01(){
  16.     }
  18.     //镇压警告的注解
  19.     @SuppressWarnings("all")
  20.     public void method02(){
  22.         ArrayList list = new ArrayList();
  23.         list.add(134);
  24.         list.add("abc");
  25.     }
  26. }

二、反射机制

1.含义：

使用到一个类，该类的class文件会加载到方法区，并且在堆中创建该类的class对象，class对象作为class文件的访问入口，反射就是获取class对象，拿到class对象就可以访问class文件（换言之，可以对该类为所欲为-属性、构造方法、方法）

  1. public class Student extends Person{
  4.     private String classId;
  5.     private String id;
  7.     public Student() {
  9.     }
  11. //    private Student(String classId, String id) {
  13. //        this.classId = classId;
  14. //        this.id = id;
  15. //    }
  17.     public Student(String name, char sex, int age, String classId, String id) {
  19.         super(name, sex, age);
  20.         this.classId = classId;
  21.         this.id = id;
  22.     }
  24.     public String getClassId() {
  26.         return classId;
  27.     }
  29.     public void setClassId(String classId) {
  31.         this.classId = classId;
  32.     }
  34.     public String getId() {
  36.         return id;
  37.     }
  39.     public void setId(String id) {
  41.         this.id = id;
  42.     }
  44.     @Override
  45.     public String toString() {
  47.         return "Student [classId=" + classId + ", id=" + id + ", getName()=" + getName() + ", getSex()=" + getSex()
  48.                 + ", getAge()=" + getAge() + "]";
  49.     }
  51. //    private String method01(String str){
  53. //        System.out.println("私有的方法 ：" + str);
  54. //        return "用良心做教育";
  55. //    }
  57.     public static void method02(){
  59.         System.out.println("静态的方法");
  60.     }
  61. }
  63. public class Person {
  66.     private String name;
  67.     private char sex;
  68.     private int age;
  70.     public Person() {
  72.     }
  74.     public Person(String name, char sex, int age) {
  76.         this.name = name;
  77.         this.sex = sex;
  78.         this.age = age;
  79.     }
  81.     public String getName() {
  83.         return name;
  84.     }
  86.     public void setName(String name) {
  88.         this.name = name;
  89.     }
  91.     public char getSex() {
  93.         return sex;
  94.     }
  96.     public void setSex(char sex) {
  98.         this.sex = sex;
  99.     }
  101.     public int getAge() {
  103.         return age;
  104.     }
  106.     public void setAge(int age) {
  108.         this.age = age;
  109.     }
  111.     @Override
  112.     public String toString() {
  114.         return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
  115.     }
  116. }
  118. import java.lang.reflect.Constructor;
  119. import java.lang.reflect.Field;
  120. import java.lang.reflect.InvocationTargetException;
  121. import java.lang.reflect.Method;
  122. import java.util.ArrayList;
  123. import java.util.Collections;
  124. import java.util.List;
  126. //反射工具类
  127. public class ReflexUtil {
  130.     //获取该类及其父类所有的属性对象
  131.     public static List<Field> getAllField(Class<?> clazz){
  134.         List<Field> list = new ArrayList<>();
  136.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  138.             Field[] fields = c.getDeclaredFields();
  139.             Collections.addAll(list, fields);
  140.         }
  142.         return list;
  143.     }
  145.     //获取该类及其父类指定的属性对象
  146.     public static Field getField(Class<?> clazz,String fieldName){
  148.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  150.             try {
  152.                 Field field = c.getDeclaredField(fieldName);
  153.                 return field;
  154.             } catch (NoSuchFieldException e) {
  155.     //如果该类中找不到属性就会出现该异常
  156.             } 
  157.         }
  158.         return null;
  159.     }
  161.     //设置对象中的属性
  162.     public static void setField(Object obj,String fieldName,Object value){
  165.         Field field = getField(obj.getClass(), fieldName);
  166.         field.setAccessible(true);
  167.         try {
  169.             field.set(obj, value);
  170.         } catch (IllegalArgumentException e) {
  172.             e.printStackTrace();
  173.         } catch (IllegalAccessException e) {
  175.             e.printStackTrace();
  176.         }
  177.     }
  179.     //获取该类及其父类所有的构造对象
  180.     public static List<Constructor<?>> getAllConstructor(Class<?> clazz){
  183.         List<Constructor<?>> list = new ArrayList<>();
  185.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  187.             Constructor<?>[] constructors = c.getDeclaredConstructors();
  188.             Collections.addAll(list, constructors);
  189.         }
  191.         return list;
  192.     }
  194.     //创建该类的对象
  195.     public static <T> T newInstance(Class<T> clazz,Class<?>[] parameterTypes,Object[] values){
  198.         try {
  200.             Constructor<T> constructor = clazz.getDeclaredConstructor(parameterTypes);
  201.             constructor.setAccessible(true);
  202.             T t = constructor.newInstance(values);
  203.             return t;
  204.         } catch (NoSuchMethodException e) {
  206.             e.printStackTrace();
  207.         } catch (SecurityException e) {
  209.             e.printStackTrace();
  210.         } catch (InstantiationException e) {
  212.             e.printStackTrace();
  213.         } catch (IllegalAccessException e) {
  215.             e.printStackTrace();
  216.         } catch (IllegalArgumentException e) {
  218.             e.printStackTrace();
  219.         } catch (InvocationTargetException e) {
  221.             e.printStackTrace();
  222.         }
  224.         return null;
  225.     }
  227.     //获取该类及其父类所有的方法对象
  228.     public static List<Method> getAllMethod(Class<?> clazz){
  231.         List<Method> list = new ArrayList<>();
  233.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  235.             Method[] methods = c.getDeclaredMethods();
  236.             Collections.addAll(list, methods);
  237.         }
  239.         return list;
  240.     }
  242.     //获取指定的方法对象
  243.     public static Method getMethod(Class<?> clazz,String methodName,Class<?>... parameterTypes){
  245.         for(Class<?> c = clazz;c != null;c = c.getSuperclass() ){
  247.             try {
  249.                 Method method = c.getDeclaredMethod(methodName, parameterTypes);
  250.                 return method;
  251.             } catch (NoSuchMethodException e) {
  253.             } 
  254.         }
  255.         return null;
  256.     }
  258.     //调用成员方法
  259.     public static Object invoke(Object obj,String methodName,Class<?>[] parameterTypes,Object[] values){
  261.         Method method = getMethod(obj.getClass(), methodName, parameterTypes);
  262.         method.setAccessible(true);
  263.         try {
  265.             Object invoke = method.invoke(obj, values);
  266.             return invoke;
  267.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  269.             e.printStackTrace();
  270.         }
  271.         return null;
  272.     }
  274.     //调用静态方法
  275.     public static Object invoke(Class<?> clazz,String methodName,Class<?>[] parameterTypes,Object[] values){
  277.         Method method = getMethod(clazz, methodName, parameterTypes);
  278.         method.setAccessible(true);
  279.         try {
  281.             Object invoke = method.invoke(null, values);//静态方法直接填null，因为不需要对象去调用
  282.             return invoke;
  283.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  285.             e.printStackTrace();
  286.         }
  287.         return null;
  288.     }
  289. }

2.利用反射获取class对象

  1. 方案一
  2. public class Test01 {
  5.     public static void main(String[] args) throws ClassNotFoundException {
  8.         //方式1：通过该类的对象获取class对象
  9.         Student stu = new Student();
  10.         Class<? extends Student> class1 = stu.getClass();
  12.         //方式2：通过类名获取class对象
  13.         Class<? extends Student> class2 = Student.class;
  15.         //方式3：通过Class类的静态方法forName加上类的全路径获取class对象
  16.         Class<?> class3 = Class.forName("com.gl.reflex01.Student");
  18.         System.out.println(class1 == class2);//true
  19.         System.out.println(class2 == class3);//true
  20.     }
  21. }
  23. 方案二
  24. import java.io.IOException;
  25. import java.util.Properties;
  27. public class Test02 {
  30.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  33.         Properties p = new Properties();
  34.         p.load(Test02.class.getClassLoader().getResourceAsStream("classpath.properties"));
  35.         String path = p.getProperty("path");
  37.         Class<?> class1 = Class.forName(path);
  38.         System.out.println(class1.getName());
  40.     }
  41. }

3.利用反射操作属性 – Field

  1. public class Test03 {
  4.     public static void main(String[] args) throws Exception {
  7. //        Properties p = new Properties();
  8. //        p.load(Test03.class.getClassLoader().getResourceAsStream("classpath.properties"));
  9. //        String path = p.getProperty("path");
  10. //        
  11. //        Class<?> clazz = Class.forName(path);
  13.         //获取该类和父类的公有的属性对象
  14. //        Field[] fields = clazz.getFields();
  15. //        for (Field field : fields) {
  17. //            System.out.println(field);
  18. //        }
  20.         //获取该类所有的属性对象
  21. //        Field[] fields = clazz.getDeclaredFields();
  22. //        for (Field field : fields) {
  24. //            System.out.println(field);
  25. //      }
  27.         //获取该类及其父类所有的属性对象
  28. //        List<Field> fields = ReflexUtil.getAllField(clazz);
  29. //        for (Field field : fields) {
  31. //            System.out.println(field);
  32. //        }
  34.         //获取该类指定的公有的属性对象
  35. //        Field field = clazz.getField("classId");
  36. //        System.out.println(field);
  38.         //获取该类指定的属性对象
  39. //        Field field = clazz.getDeclaredField("classId");
  40. //        System.out.println(field);
  42.         //获取该类及其父类指定的属性对象
  43. //        Field field = ReflexUtil.getField(clazz, "name");
  44. //        System.out.println(field);
  46.         //利用反射机制去操作对象中的属性
  48. //        Student stu = new Student();
  49. //        Field fieldName = ReflexUtil.getField(clazz, "name");
  50. //        fieldName.setAccessible(true);//设置修改权限
  51. //        fieldName.set(stu, "关羽");
  52. //        System.out.println(stu);
  55.         //利用反射机制去操作对象中的属性 -- 封装成方法
  56.         Student stu = new Student();
  57.         ReflexUtil.setField(stu, "name", "关羽");
  58.         ReflexUtil.setField(stu, "sex", '男');
  59.         ReflexUtil.setField(stu, "age", 25);
  60.         ReflexUtil.setField(stu, "classId", "2022");
  61.         ReflexUtil.setField(stu, "id", "002");
  62.         System.out.println(stu);
  63.     }
  64. }

4.利用反射操作构造方法

  1. import java.util.Properties;
  3. public class Test04 {
  6.     public static void main(String[] args) throws Exception {
  9.         Properties p = new Properties();
  10.         p.load(Test03.class.getClassLoader().getResourceAsStream("classpath.properties"));
  11.         String path = p.getProperty("path");
  13.         @SuppressWarnings("unchecked")
  14.         Class<Student> clazz = (Class<Student>) Class.forName(path);
  16.         //获取该类公有的构造方法对象
  17. //        Constructor<?>[] constructors = clazz.getConstructors();
  18. //        for (Constructor<?> constructor : constructors) {
  20. //            System.out.println(constructor);
  21. //        }
  24.         //获取该类所有的构造方法对象
  25. //        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
  26. //        for (Constructor<?> constructor : constructors) {
  28. //            System.out.println(constructor);
  29. //        }
  32.         //获取该类及其父类所有的构造方法对象
  33. //        List<Constructor<?>> allConstructor = ReflexUtil.getAllConstructor(clazz);
  34. //        for (Constructor<?> constructor : allConstructor) {
  36. //            System.out.println(constructor);
  37. //        }
  39.         //获取该类指定的公有的构造方法对象并创建该类对象 -- 无参构造
  40. //        Constructor<?> constructor = clazz.getConstructor();//获取公有的无参构造
  41. //        Student stu = (Student) constructor.newInstance();//利用构造方法对象创建该类的对象
  42. //        System.out.println(stu);
  44.         //直接利用无参构造创建对象
  45. //        Student stu = (Student) clazz.newInstance();//底层：获取该类的无参构造对象，并创建该类的对象
  46. //        System.out.println(stu);
  48.         //获取该类指定的公有的构造方法对象并创建该类对象 -- 有参构造
  49. //        Constructor<?> constructor = clazz.getConstructor(String.class,char.class,int.class,String.class,String.class);//获取公有的有参构造
  50. //        Student stu = (Student) constructor.newInstance("刘备",'男',23,"2022","001");//利用构造方法对象创建该类的对象
  51. //        System.out.println(stu);
  53.         //获取该类指定的构造方法对象并创建该类对象 -- 私有的有参构造
  54. //        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class,String.class);//获取有参构造
  55. //        constructor.setAccessible(true);//设置修改权限
  56. //        Student stu = (Student) constructor.newInstance("2022","001");//利用构造方法对象创建该类的对象
  57. //        System.out.println(stu);
  59.         //利用反射机制去创建该类的对象 -- 封装成方法
  60.         Student stu1 = ReflexUtil.newInstance(clazz, null, null);
  61.         System.out.println(stu1);
  62.         Student stu2 = ReflexUtil.newInstance(clazz,new Class[]{
  63.     String.class,char.class,int.class,String.class,String.class},new Object[]{
  64.     "刘备",'男',23,"2022","001"});
  65.         System.out.println(stu2);
  66.     }
  67. }

5.利用反射操作方法

  1. import java.util.Properties;
  3. public class Test05 {
  6.     public static void main(String[] args) throws Exception {
  9.         Properties p = new Properties();
  10.         p.load(Test03.class.getClassLoader().getResourceAsStream("classpath.properties"));
  11.         String path = p.getProperty("path");
  13.         @SuppressWarnings("unchecked")
  14.         Class<Student> clazz = (Class<Student>) Class.forName(path);
  16.         //获取该类以及父类公有的方法对象
  17. //        Method[] methods = clazz.getMethods();
  18. //        for (Method method : methods) {
  20. //            System.out.println(method);
  21. //        }
  23.         //获取该类所有的方法对象
  24. //        Method[] methods = clazz.getDeclaredMethods();
  25. //        for (Method method : methods) {
  27. //            System.out.println(method);
  28. //        }
  30.         //获取该类及其父类所有的方法对象
  31. //        List<Method> list = ReflexUtil.getAllMethod(clazz);
  32. //        for (Method method : list) {
  34. //            System.out.println(method);
  35. //        }
  37.         //调用公有的方法 -- 无参数的方法
  38. //        Student stu = ReflexUtil.newInstance(clazz,new Class[]{String.class,char.class,int.class,String.class,String.class},new Object[]{"刘备",'男',23,"2022","001"});
  39. //        Method method = clazz.getMethod("getClassId");
  40. //        Object invoke = method.invoke(stu);
  41. //        System.out.println("返回值：" + invoke);
  43.         //调用公有的方法 -- 有参数的方法
  44. //        Student stu = ReflexUtil.newInstance(clazz,new Class[]{String.class,char.class,int.class,String.class,String.class},new Object[]{"刘备",'男',23,"2022","001"});
  45. //        Method method = clazz.getMethod("setClassId",String.class);
  46. //        Object invoke = method.invoke(stu,"2212");
  47. //        System.out.println("返回值：" + invoke);
  48. //        System.out.println(stu);
  50.         //调用私有的方法
  51. //        Student stu = ReflexUtil.newInstance(clazz,new Class[]{String.class,char.class,int.class,String.class,String.class},new Object[]{"刘备",'男',23,"2022","001"});
  52. //        Method method = clazz.getDeclaredMethod("method01", String.class);
  53. //        method.setAccessible(true);
  54. //        Object invoke = method.invoke(stu, "abc");
  55. //        System.out.println("返回值：" + invoke);
  57.         //调用方法 -- 封装方法
  58. //        Student stu = ReflexUtil.newInstance(clazz,new Class[]{String.class,char.class,int.class,String.class,String.class},new Object[]{"刘备",'男',23,"2022","001"});
  59. //        Object invoke = ReflexUtil.invoke(stu, "method01", new Class[]{String.class}, new Object[]{"abc"});
  60. //        System.out.println("返回值：" + invoke);
  63.         //调用静态方法
  64.         Object invoke = ReflexUtil.invoke(clazz, "method02", null,null);
  65.         System.out.println("返回值：" + invoke);
  66.     }
  67. }

6.利用反射操作泛型

注意：类上的泛型是获取不到的

  1. import java.lang.reflect.Method;
  2. import java.lang.reflect.ParameterizedType;
  3. import java.lang.reflect.Type;
  4. import java.util.ArrayList;
  5. import java.util.HashMap;
  7. public class Test06 {
  10.     public static void main(String[] args) throws Exception {
  13.         Class<?> clazz = Test06.class;
  14.         Method method = clazz.getDeclaredMethod("method", ArrayList.class,HashMap.class);
  16.         //获取参数上的泛型
  17.         Type[] genericParameterTypes = method.getGenericParameterTypes();//获取参数类型
  18.         for (Type type : genericParameterTypes) {
  20.             ParameterizedType pt = (ParameterizedType) type;//把type强转为参数类型
  21.             Type[] actualTypeArguments = pt.getActualTypeArguments();//获取参数类型上的泛型并返回泛型数组（为什么返回的是数组？因为一个参数上有可能有多个泛型）
  22.             for (Type t : actualTypeArguments) {
  24.                 System.out.println(t);
  25.             }
  26.         }
  27.         System.out.println("-------------");
  29.         //获取返回值上的泛型
  30.         Type genericReturnType = method.getGenericReturnType();
  31.         ParameterizedType pt = (ParameterizedType)genericReturnType;
  32.         Type[] actualTypeArguments = pt.getActualTypeArguments();//获取返回值类型上的泛型并返回泛型数组（为什么返回的是数组？因为一个参数上有可能有多个泛型）
  33.         for (Type type : actualTypeArguments) {
  35.             System.out.println(type);
  36.         }
  37.     }
  39.     public HashMap<String, Integer> method(ArrayList<String> list,HashMap<String, Integer> map){
  41.         return null;
  42.     }
  44. }

7.利用反射操作数组

  1. Arrays -- 数组的工具类
  2. Array --- 数组的反射类
  4. import java.lang.reflect.Array;
  6. public class Test07 {
  8.     public static void main(String[] args) throws Exception {
  11.         //创建数组
  12.         int[] is = (int[]) Array.newInstance(int.class, 5);
  14.         //获取数组的长度
  15.         System.out.println("获取数组的长度：" + Array.getLength(is));//5
  17.         //通过下标设置元素
  18.         Array.set(is, 2, 888);
  20.         //遍历数组
  21.         for(int i = 0;i<Array.getLength(is);i++){
  23.             //通过下标获取元素
  24.             Object element = Array.get(is, i);
  25.             System.out.println(element);
  26.         }
  28.     }
  29. }

8.反射机制 之 扩展运用封装代码

  1. public class Person {
  4.     private String name;
  5.     private char sex;
  6.     private int age;
  8.     public Person() {
  10.     }
  12.     public Person(String name, char sex, int age) {
  14.         this.name = name;
  15.         this.sex = sex;
  16.         this.age = age;
  17.     }
  19.     public String getName() {
  21.         return name;
  22.     }
  24.     public void setName(String name) {
  26.         this.name = name;
  27.     }
  29.     public char getSex() {
  31.         return sex;
  32.     }
  34.     public void setSex(char sex) {
  36.         this.sex = sex;
  37.     }
  39.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  46.         this.age = age;
  47.     }
  49.     @Override
  50.     public String toString() {
  52.         return "Person [names=" + name + ", sex=" + sex + ", age=" + age + "]";
  53.     }
  55. }
  57. import java.lang.reflect.Constructor;
  58. import java.lang.reflect.Field;
  59. import java.lang.reflect.InvocationTargetException;
  60. import java.lang.reflect.Method;
  61. import java.util.ArrayList;
  62. import java.util.Collections;
  63. import java.util.List;
  65. //反射工具类
  66. public class ReflexUtil {
  69.     //获取该类及其父类所有的属性对象
  70.     public static List<Field> getAllField(Class<?> clazz){
  73.         List<Field> list = new ArrayList<>();
  75.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  77.             Field[] fields = c.getDeclaredFields();
  78.             Collections.addAll(list, fields);
  79.         }
  81.         return list;
  82.     }
  84.     //获取该类及其父类指定的属性对象
  85.     public static Field getField(Class<?> clazz,String fieldName){
  87.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  89.             try {
  91.                 Field field = c.getDeclaredField(fieldName);
  92.                 return field;
  93.             } catch (NoSuchFieldException e) {
  94.     //如果该类中找不到属性就会出现该异常
  95.             } 
  96.         }
  97.         return null;
  98.     }
  100.     //设置对象中的属性
  101.     public static void setField(Object obj,String fieldName,Object value){
  104.         Field field = getField(obj.getClass(), fieldName);
  105.         field.setAccessible(true);
  106.         try {
  108.             field.set(obj, value);
  109.         } catch (IllegalArgumentException e) {
  111.             e.printStackTrace();
  112.         } catch (IllegalAccessException e) {
  114.             e.printStackTrace();
  115.         }
  116.     }
  118.     //获取该类及其父类所有的构造对象
  119.     public static List<Constructor<?>> getAllConstructor(Class<?> clazz){
  122.         List<Constructor<?>> list = new ArrayList<>();
  124.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  126.             Constructor<?>[] constructors = c.getDeclaredConstructors();
  127.             Collections.addAll(list, constructors);
  128.         }
  130.         return list;
  131.     }
  133.     //创建该类的对象
  134.     public static <T> T newInstance(Class<T> clazz,Class<?>[] parameterTypes,Object[] values){
  137.         try {
  139.             Constructor<T> constructor = clazz.getDeclaredConstructor(parameterTypes);
  140.             constructor.setAccessible(true);
  141.             T t = constructor.newInstance(values);
  142.             return t;
  143.         } catch (NoSuchMethodException e) {
  145.             e.printStackTrace();
  146.         } catch (SecurityException e) {
  148.             e.printStackTrace();
  149.         } catch (InstantiationException e) {
  151.             e.printStackTrace();
  152.         } catch (IllegalAccessException e) {
  154.             e.printStackTrace();
  155.         } catch (IllegalArgumentException e) {
  157.             e.printStackTrace();
  158.         } catch (InvocationTargetException e) {
  160.             e.printStackTrace();
  161.         }
  163.         return null;
  164.     }
  166.     //获取该类及其父类所有的方法对象
  167.     public static List<Method> getAllMethod(Class<?> clazz){
  170.         List<Method> list = new ArrayList<>();
  172.         for (Class<?> c = clazz;c != null;c = c.getSuperclass()) {
  174.             Method[] methods = c.getDeclaredMethods();
  175.             Collections.addAll(list, methods);
  176.         }
  178.         return list;
  179.     }
  181.     //获取指定的方法对象
  182.     public static Method getMethod(Class<?> clazz,String methodName,Class<?>... parameterTypes){
  184.         for(Class<?> c = clazz;c != null;c = c.getSuperclass() ){
  186.             try {
  188.                 Method method = c.getDeclaredMethod(methodName, parameterTypes);
  189.                 return method;
  190.             } catch (NoSuchMethodException e) {
  192.             } 
  193.         }
  194.         return null;
  195.     }
  197.     //调用成员方法
  198.     public static Object invoke(Object obj,String methodName,Class<?>[] parameterTypes,Object[] values){
  200.         Method method = getMethod(obj.getClass(), methodName, parameterTypes);
  201.         method.setAccessible(true);
  202.         try {
  204.             Object invoke = method.invoke(obj, values);
  205.             return invoke;
  206.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  208.             e.printStackTrace();
  209.         }
  210.         return null;
  211.     }
  213.     //调用静态方法
  214.     public static Object invoke(Class<?> clazz,String methodName,Class<?>[] parameterTypes,Object[] values){
  216.         Method method = getMethod(clazz, methodName, parameterTypes);
  217.         method.setAccessible(true);
  218.         try {
  220.             Object invoke = method.invoke(null, values);//静态方法直接填null，因为不需要对象去调用
  221.             return invoke;
  222.         } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
  224.             e.printStackTrace();
  225.         }
  226.         return values;
  227.     }
  228. }
  230. public class Student extends Person{
  233.     private String classId;
  234.     private String id;
  236.     public Student() {
  238.     }
  240.     public Student(String name, char sex, int age, String classId, String id) {
  242.         super(name, sex, age);
  243.         this.classId = classId;
  244.         this.id = id;
  245.     }
  247.     public String getClassId() {
  249.         return classId;
  250.     }
  252.     public void setClassId(String classId) {
  254.         this.classId = classId;
  255.     }
  257.     public String getId() {
  259.         return id;
  260.     }
  262.     public void setId(String id) {
  264.         this.id = id;
  265.     }
  269. //    private String method01(String str){
  271. //    System.out.println("私有的方法 ：" + str);
  272. //    return "用良心做教育";
  273. //}
  275.     @Override
  276.     public String toString() {
  278.         return "Student [classId=" + classId + ", id=" + id + ", getName()=" + getName() + ", getSex()=" + getSex()
  279.                 + ", getAge()=" + getAge() + "]";
  280.     }
  282.     public static void method02(){
  284.         System.out.println("静态的方法");
  285.     }
  286. }

9.反射机制 之 扩展属性的运用

  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.Modifier;
  3. import java.util.Properties;
  5. public class Test01 {
  8.     public static void main(String[] args) throws Exception {
  11.         Properties p = new Properties();
  12.         p.load(Test01.class.getClassLoader().getResourceAsStream("classpath.properties"));
  13.         String path = p.getProperty("path");
  15.         Class<?> clazz = Class.forName(path);
  17.         //获取学生类中的name属性
  18.         Field field = ReflexUtil.getField(clazz, "name");
  20.         //获取属性参数值
  21.         int modifiers = field.getModifiers();
  23.         System.out.println("判断属性是否是私有化的：" + Modifier.isPrivate(modifiers));
  24.         System.out.println("判断属性是否是Protected的：" + Modifier.isProtected(modifiers));
  25.         System.out.println("判断属性是否是公有的：" + Modifier.isPublic(modifiers));
  26.         System.out.println("判断属性是否是静态的：" + Modifier.isStatic(modifiers));
  27.         System.out.println("判断属性是否是常量的：" + Modifier.isFinal(modifiers));
  28.     }
  29. }

10.反射机制 之 扩展方法的运用

  1. import java.lang.reflect.Method;
  2. import java.lang.reflect.Modifier;
  3. import java.util.Properties;
  5. public class Test02 {
  8.     @SuppressWarnings("all")
  9.     public static void main(String[] args) throws Exception {
  12.         Properties p = new Properties();
  13.         p.load(Test02.class.getClassLoader().getResourceAsStream("classpath.properties"));
  14.         String path = p.getProperty("path");
  16.         Class<?> clazz = Class.forName(path);
  18.         //获取学生类中的method02
  19.         Method method = ReflexUtil.getMethod(clazz, "method02",null);
  21.         //获取方法参数值
  22.         int modifiers = method.getModifiers();
  24.         System.out.println("判断方法是否是私有化的：" + Modifier.isPrivate(modifiers));
  25.         System.out.println("判断方法是否是Protected的：" + Modifier.isProtected(modifiers));
  26.         System.out.println("判断方法是否是公有的：" + Modifier.isPublic(modifiers));
  27.         System.out.println("判断方法是否是静态的：" + Modifier.isStatic(modifiers));
  28.         System.out.println("判断方法是否不可重写的：" + Modifier.isFinal(modifiers));
  29.         System.out.println("判断方法是否同步的：" + Modifier.isSynchronized(modifiers));
  30.         System.out.println("判断方法是否抽象的：" + Modifier.isAbstract(modifiers));
  31.     }
  32. }

11.反射案例之万能数组扩容/复制

  1. import java.lang.reflect.Array;
  2. import java.util.Arrays;
  4. public class Test01 {
  7.     public static void main(String[] args) {
  10.         int[] is = {
  11.     1,2,3,4,5};
  12.         int[] copy1 = copy(is,10);
  13.         System.out.println(Arrays.toString(copy1));
  15.         System.out.println("---------");
  17.         String[] names = {
  18.     "后裔","狄仁杰","李元芳","孙尚香"};
  19.         String[] copy2 = copy(names,10);
  20.         System.out.println(Arrays.toString(copy2));
  21.     }
  23.     public static <T> T copy(T t,int newLength){
  25.         //获取数组的class对象
  26.         Class<? extends Object> clazz = t.getClass();
  27.         //获取数组元素类型的class对象
  28.         Class<?> elementClazz = clazz.getComponentType();
  29.         //创建数组
  30.         @SuppressWarnings("unchecked")
  31.         T arr = (T) Array.newInstance(elementClazz, newLength);
  32.         //遍历原数组
  33.         for (int i = 0; i < Array.getLength(t); i++) {
  35.             //获取指定下标上的元素
  36.             Object element = Array.get(t, i);
  37.             //将元素设置给新数组
  38.             Array.set(arr, i, element);
  39.         }
  40.         return arr;
  41.     }
  42. }

12.反射案例 之 逻辑与业务分离的思想

  • 业务场景：获取数据
  • 分析：
  • 获取本地数据 – 代码
  • 获取网络数据 – 代码

  • 获取其他数据 – 代码

    import java.util.List;
    import java.util.Scanner;

    public class Test01 {

  1.     public static void main(String[] args) {
  3.         Scanner scan = new Scanner(System.in);
  4.         printMenu();
  5.         int num = scan.nextInt();
  7.         DataSource dataSource =    getDataSourceObj(num);
  8.         dataSource.getDataSource();
  10.         scan.close();
  11.     }
  13.         public static DataSource getDataSourceObj(int num){
  15.             List<String> classlist = DataContainer.classList;
  16.             String classPath = classlist.get(num-1);
  17.             try {
  19.                 Class<?> clazz = Class.forName(classPath);
  20.                 DataSource dataSource = (DataSource) clazz.newInstance();
  21.                 return dataSource;
  22.             } catch (ClassNotFoundException e) {
  24.                 e.printStackTrace();
  25.             } catch (InstantiationException e) {
  27.                 e.printStackTrace();
  28.             } catch (IllegalAccessException e) {
  30.                 e.printStackTrace();
  31.             }
  33.         return null;
  35.     }
  37.     private static void printMenu() {
  39.         List<String> menulist = DataContainer.menuList;
  40.         System.out.println("请选择获取数据的方式：");
  41.         for (String str : menulist) {
  43.             System.out.println(str);
  44.         }
  45.     }
  46. }
  48. import java.io.IOException;
  49. import java.util.ArrayList;
  50. import java.util.List;
  51. import java.util.Properties;
  53. public class DataContainer {
  56.     public static final List<String> menuList;
  57.     public static final List<String> classList;
  59.     static{
  61.         //初始化菜单集合
  62.         menuList = new ArrayList<>();
  63.         Properties menuProperties = new Properties();
  65.         try {
  67.             menuProperties.load(DataContainer.class.getClassLoader().getResourceAsStream("menuConfig.properties"));
  68.         } catch (IOException e) {
  70.             e.printStackTrace();
  71.         }
  72.         String menu = menuProperties.getProperty("menu");
  73.         String[] menuSplit = menu.split(",");
  74.         for (String str : menuSplit) {
  76.             menuList.add(str);
  77.         }
  79.         //初始化类路径集合
  80.         classList = new ArrayList<>();
  81.         Properties classProperties = new Properties();
  83.         try {
  85.             classProperties.load(DataContainer.class.getClassLoader().getResourceAsStream("classConfig.properties"));
  86.         } catch (IOException e) {
  88.             e.printStackTrace();
  89.         }
  91.         String path = classProperties.getProperty("path");
  92.         String[] pathSplit = path.split(",");
  93.         for (String str : pathSplit) {
  95.             classList.add(str);
  96.         }
  97.     }
  98. }
  100. public abstract class DataSource {
  102.     public abstract void getDataSource();
  103. }
  105. public class LocalDataSource extends DataSource{
  108.     @Override
  109.     public void getDataSource() {
  111.         System.out.println("执行获取本地数据的代码...");
  113.     }
  115. }
  117. public class NetworkDataSource extends DataSource{
  120.     @Override
  121.     public void getDataSource() {
  123.         System.out.println("执行获取网络数据的代码...");
  125.     }
  127. }
  129. public class OtherDataSource extends DataSource{
  132.     @Override
  133.     public void getDataSource() {
  135.         System.out.println("执行获取其他数据的代码...");
  137.     }
  139. }

13.反射案例 之 获取注解信息

  1. import java.lang.reflect.Field;
  3. public class Test01 {
  6.     public static void main(String[] args) {
  9.         Student stu = new Student("刘备", '男', 23);
  11.         Class<? extends Student> clazz = stu.getClass();
  13.         //获取类上注解的信息
  14.         TableInfo tableInfoAnnotation = clazz.getAnnotation(TableInfo.class);
  15.         String tableName = tableInfoAnnotation.value();
  16.         System.out.println(tableName);
  18.         //获取属性上注解的信息
  19.         Field[] fields = clazz.getDeclaredFields();
  20.         for (Field field : fields) {
  22.             FieldInfo fieldInfoAnnotation = field.getAnnotation(FieldInfo.class);
  23.             String name = fieldInfoAnnotation.name();
  24.             String type = fieldInfoAnnotation.type();
  25.             int length = fieldInfoAnnotation.length();
  27.             Object value = null;
  28.             try {
  30.                 field.setAccessible(true);
  31.                 value = field.get(stu);
  32.             } catch (IllegalArgumentException e) {
  34.                 e.printStackTrace();
  35.             } catch (IllegalAccessException e) {
  37.                 e.printStackTrace();
  38.             }
  40.             System.out.println(name + " -- " + type + " -- " + length + " -- " + value);
  41.         }
  44.         //insert into s_student(s_name,s_sex,s_age) values("刘备","男",23)
  45.     }
  46. }
  48. @TableInfo("s_student")
  49. public class Student {
  52.     @FieldInfo(name="s_name",type="varchar",length=32)
  53.     private String name;
  55.     @FieldInfo(name="s_sex",type="varchar",length=32)
  56.     private char sex;
  58.     @FieldInfo(name="s_age",type="int",length=3)
  59.     private int age;
  61.     public Student() {
  63.     }
  65.     public Student(String name, char sex, int age) {
  67.         this.name = name;
  68.         this.sex = sex;
  69.         this.age = age;
  70.     }
  72.     public String getName() {
  74.         return name;
  75.     }
  77.     public void setName(String name) {
  79.         this.name = name;
  80.     }
  82.     public char getSex() {
  84.         return sex;
  85.     }
  87.     public void setSex(char sex) {
  89.         this.sex = sex;
  90.     }
  92.     public int getAge() {
  94.         return age;
  95.     }
  97.     public void setAge(int age) {
  99.         this.age = age;
  100.     }
  102.     @Override
  103.     public String toString() {
  105.         return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
  106.     }
  108. }
  110. import java.lang.annotation.ElementType;
  111. import java.lang.annotation.Retention;
  112. import java.lang.annotation.RetentionPolicy;
  113. import java.lang.annotation.Target;
  115. @Target(ElementType.TYPE)
  116. @Retention(RetentionPolicy.RUNTIME)
  117. public @interface TableInfo {
  120.     String value();
  121. }
  123. import java.lang.annotation.ElementType;
  124. import java.lang.annotation.Retention;
  125. import java.lang.annotation.RetentionPolicy;
  126. import java.lang.annotation.Target;
  128. @Target(ElementType.FIELD)
  129. @Retention(RetentionPolicy.RUNTIME)
  130. public @interface FieldInfo {
  133.     String name();
  134.     String type();
  135.     int length();
  136. }

发表评论

表情：
评论列表 （有 0 条评论，133人围观）

还没有评论，来说两句吧...

相关阅读

    相关 注解与反射

    注解（Annotation）是Java中的一种元数据，它提供了一种为程序元素（类、方法、变量等）添加元数据的方式。注解可以用来描述程序元素的特性、用途和约束条件等信息。Java

    旧城等待，旧城等待，/ 0 赞/ 104 阅读

    相关 注解与反射

    注解（Annotation）是Java中的一种元数据，它提供了一种为程序元素（类、方法、变量等）添加元数据的方式。注解可以用来描述程序元素的特性、用途和约束条件等信息。Java

    约定不等于承诺〃约定不等于承诺〃/ 0 赞/ 113 阅读

    相关 注解与反射

    注解 什么是注解 Annotation(注解)是从JDK5.0开始引入的新技术 注解可以被其他程序（如：编译器等）读取，不是程序本身，可以对程序做出解释

    亦凉亦凉/ 0 赞/ 45 阅读

    相关 反射与注解

    反射与注解 一、反射 1. 使用反射机制可以动态的获取当前class的信息，比如方法的信息、注解信息、方法的参数、属性 2. 反射目的：方便开发者对框架的拓展,

    小鱼儿小鱼儿/ 0 赞/ 363 阅读