反射(reflect)和注解

无反射无框架。

反射的介绍

  1. package com.powernode.p2;
  3. public class Demo01 {
  5.     public static void main(String[] args) {
  6.         // 正向创建  --- 静态的  --- 指腹为婚
  7.         /*
  8.         * 之所以叫做静态的， 是因为我们创建对象的时候类已经固定了
  9.         * 也就是这句代码创建的就是Student的对象。不会是其他类的对象了
  10.         */
  11.         Student student = new Student("张三",20);
  12.         System.out.println(student);
  14.         System.out.println("-----------------------------------");
  16.         // 使用反射  --- 动态的
  17.         /*
  18.         * 之所以叫做动态的是因为，我们创建对象的类没有固定，可以是任意的。
  19.         *
  20.         */
  21.         try {
  22.             Class<?> aClass = Class.forName(args[0]);
  23.             Object obj = aClass.newInstance();
  24.             System.out.println(obj);
  25.         } catch (ClassNotFoundException e) {
  26.             e.printStackTrace();
  27.         } catch (IllegalAccessException e) {
  28.             e.printStackTrace();
  29.         } catch (InstantiationException e) {
  30.             e.printStackTrace();
  31.         }
  32.     }
  34. }

1655188733294.png

Class类

  1. public final class Class<T> extends Object implements Serializable, GenericDeclaration, Type, AnnotatedElement
  • 类型参数：
    T - 由此 Class 对象建模的类的类型。例如，String.class 的类型是 Class。如果将被建模的类未知，则使用 Class。

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

获取Class对象的四种方式

  1. package com.powernode.p2;
  2. /**
  3.  * 获取Class对象
  4.  *
  5.  */
  6. public class Demo02 {
  8.     public static void main(String[] args) {
  9.         // FQCN(Fully Qualified Class Name)  全限定类名  包名.类名
  10.         // 获取Class对象的方式一：Class.forName(String FQCN);   --- 推荐使用，好处就是解耦
  11.         try {
  12.             Class<?> aClass = Class.forName("com.powernode.p2.Student");
  13.             System.out.println(aClass);
  14.             System.out.println(aClass.getName());
  15.         } catch (ClassNotFoundException e) {
  16.             e.printStackTrace();
  17.         }
  20.         System.out.println("--------------------------------");
  22.         // 获取Class对象的方式二：数据类型.class  --- 作为参数传递的时候比较常用
  23.         Class<Student> studentClass = Student.class;
  24.         System.out.println(studentClass);
  25.         System.out.println(studentClass.getName());
  27.         System.out.println(int.class);
  28.         System.out.println(boolean.class);
  29.         System.out.println(int[][].class);
  30.         System.out.println(void.class);
  32.         System.out.println("--------------------------------");
  34.         // 获取Class对象的方式三：对象.getClass()
  35.         Student student = new Student();
  36.         Class<? extends Student> aClass = student.getClass();
  37.         System.out.println(aClass);
  38.         System.out.println(aClass.getName());
  40.         System.out.println("--------------------------------");
  42.         // 获取Class对象的方式四： 包装类.TYPE
  43.         Class<Integer> integerClass = Integer.TYPE;
  44.         System.out.println(integerClass);
  45.         Class<Double> doubleClass = Double.TYPE;
  46.         System.out.println(doubleClass);
  47.         Class<Character> characterClass = Character.TYPE;
  48.         System.out.println(characterClass);
  49.     }
  50. }

使用反射获取包信息

  1. package com.powernode.p2;
  2. /**
  3.  * 使用反射获取包的信息
  4.  *
  5.  *    反射机制就是将类的各个组成部分(属性，方法，构造器)封装为其它对象。
  6.  *
  7.  *     使用反射获取包的信息，会将封装成Package对象
  8.  *
  9.  */
  10. public class PackageDemo {
  12.     public static void main(String[] args) {
  13.         try {
  14.             // 1. 获取Class
  15.             Class<?> aClass = Class.forName("com.powernode.p2.Student");
  16.             // 2. 拿到Class后，使用反射你就可以为所欲为
  17.             Package aPackage = aClass.getPackage();
  18.             System.out.println(aPackage);
  19.             System.out.println(aPackage.getName());
  20.         } catch (ClassNotFoundException e) {
  21.             e.printStackTrace();
  22.         }
  24.     }
  25. }

使用反射获取类信息

  1. package com.powernode.p2;
  3. import java.lang.reflect.Modifier;
  5. /**
  6.  * 使用反射获取类信息
  7.  *
  8.  */
  9. public class ClassDemo01 {
  10.     public static void main(String[] args) {
  11.         try {
  12.             // Class.forName()得到的就是类的信息了
  13.             Class<?> aClass = Class.forName("com.powernode.p2.Student");
  14.             System.out.println(aClass.getName());
  16.             // 获取类的修饰符信息
  17.             int modifiers = aClass.getModifiers();
  18.             System.out.println(modifiers); // 1 == public
  19.             // 判断类是不是public修饰的
  20.             System.out.println(Modifier.isPublic(modifiers));
  22.             // 获取继承的父类
  23.             Class<?> superclass = aClass.getSuperclass();
  24.             System.out.println(superclass.getName());
  26.             // 获取实现的接口
  27.             // 父类实现的接口，子类是没有实现的
  28.             Class<?>[] interfaces = aClass.getInterfaces();
  29.             for (Class<?> anInterface : interfaces) {
  30.                 System.out.println(anInterface.getName());
  31.             }
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37. }

使用反射通过Class创建对象

  1. Class<?> aClass = Class.forName("com.powernode.p2.Student");
  2. System.out.println(aClass.getName());
  4. /*
  5.    * 使用反射通过Class创建对象
  6.    * aClass.newInstance()是通过无参构造创建对象
  7.    * jdk9开始该方法被弃用了
  8. */
  9. Object obj = aClass.newInstance();
  10. System.out.println(obj);

使用反射获取字段

  1. package com.powernode.p2;
  3. import java.lang.reflect.Field;
  5. /**
  6.  * 使用反射获取字段:
  7.  *  javabean中的成员变量也叫作字段Field
  8.  *
  9.  * 反射机制就是将类的各个组成部分(属性，方法，构造器)封装为其它对象。
  10.  *   反射就会将成员变量信息封装成Field对象
  11.  *
  12.  *
  13.  */
  14. public class FieldDemo01 {
  16.     public static void main(String[] args) {
  17.         Class<Student> studentClass = Student.class;
  18.         try {
  19.             // 获取指定的public字段
  20.             // getField()可以获取本类定义的字段或者是继承的字段
  21.             Field nameField = studentClass.getField("name");
  22.             System.out.println(nameField);
  23.             System.out.println(nameField.getName());
  24.             System.out.println("-----------------------------");
  26.             //  获取本类定义的或继承的所有public字段
  27.             Field[] fields = studentClass.getFields();
  28.             for (Field field : fields) {
  29.                 System.out.println("field= " + field);
  30.             }
  32.             System.out.println("-----------------------------");
  33.             /*
  34.             * Declared 已声明过的。
  35.             * 1. 本类中定义的才叫做声明。
  36.             * 2. Declared可以获取任意访问权限的
  37.             *
  38.             */
  39.             Field ageField = studentClass.getDeclaredField("age");
  40.             System.out.println(ageField);
  41.             System.out.println(ageField.getName());
  43.             // 获取字段的访问权限
  44.             System.out.println(ageField.getModifiers());
  46.             System.out.println("-----------------------------");
  47.             Field[] declaredFields = studentClass.getDeclaredFields();
  48.             for (Field declaredField : declaredFields) {
  49.                 System.out.println("declaredField= "+ declaredField);
  50.             }
  51.         } catch (NoSuchFieldException e) {
  52.             e.printStackTrace();
  53.         }
  54.     }
  55. }

使用反射给字段赋值和取值

  1. package com.powernode.p2;
  3. import java.lang.reflect.Field;
  5. /**
  6.  * 使用反射给字段赋值和取值
  7.  */
  8. public class FieldDemo02 {
  10.     public static void main(String[] args) {
  11.         Class<Student> studentClass = Student.class;
  13.         try {
  14.             // 获取字段对象
  15.             Field nameField = studentClass.getField("name");
  16.             // 取值
  17.             /*
  18.             * get(Object obj)中的参数obi表示获取哪一个对象的字段
  19.             */
  20.             Student student = studentClass.newInstance();
  21.             Object value = nameField.get(student);
  22.             System.out.println(value); // null
  24.             // 赋值
  25.             /*
  26.             * set(Object obj, Object value)
  27.             * 第一个参数表示给哪个对象的字段赋值
  28.             * 第二参数表示给字段赋什么值
  29.             */
  30.             nameField.set(student,"李四");
  31.             value = nameField.get(student);
  32.             System.out.println(value); // 李四
  35.             System.out.println("------------------------------");
  37.             // 给private int age字段取值和赋值
  38.             Field ageField = studentClass.getDeclaredField("age");
  39.             // 暴力访问
  40.             // 私有的字段不论是取值还是赋值都需要设置暴力访问
  41.             // 设置为true表示反射对象在使用时忽略Java语言访问检查
  42. //            ageField.setAccessible(true);
  43.             Object ageValue = ageField.get(student);
  44.             System.out.println(ageValue); // 0
  46.             ageField.set(student,23);
  47.             ageValue = ageField.get(student);
  48.             System.out.println(ageValue); // 23
  49.         } catch (NoSuchFieldException e) {
  50.             e.printStackTrace();
  51.         } catch (IllegalAccessException e) {
  52.             e.printStackTrace();
  53.         } catch (InstantiationException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57. }

使用反射获取构造信息

  1. package com.powernode.p2;
  3. import java.lang.reflect.Constructor;
  5. /**
  6.  * 使用反射获取构造信息
  7.  *
  8.  * 反射机制就是将类的各个组成部分(属性，方法，构造器)封装为其它对象。
  9.  *
  10.  *    反射会将构造函数封装成Constructor对象
  11.  *
  12.  *
  13.  */
  14. public class ConstructorDemo01 {
  16.     public static void main(String[] args) {
  17.         Class<Student> studentClass = Student.class;
  18.         /*
  19.         * getConstructor(Class<?>... parameterTypes)
  20.         * 参数表示是的构造的参数类型的Class
  21.         *
  22.         */
  23.         try {
  24.             // 获取public的无参构造
  25.             Constructor<Student> constructor = studentClass.getConstructor();
  26.             System.out.println(constructor);
  27.             System.out.println(constructor.getName());
  29.             System.out.println("--------------------");
  30.             // 获取public的带参构造
  31.             Constructor<Student> constructor1 = studentClass.getConstructor(String.class,int.class);
  32.             System.out.println(constructor1);
  33.             System.out.println(constructor1.getName());
  35.             System.out.println("--------------------");
  36.             Constructor<?>[] constructors = studentClass.getConstructors();
  37.             for (Constructor<?> constructor2 : constructors) {
  38.                 System.out.println("constructor2= " + constructor2);
  39.             }
  41.             System.out.println("--------------------");
  42.             // 获取声明过的指定构造函数
  43.             Constructor<Student> declaredConstructor = studentClass.getDeclaredConstructor(String.class);
  44.             System.out.println(declaredConstructor);
  46.             System.out.println("--------------------");
  47.             // 获取声明过的所有构造函数
  48.             Constructor<?>[] declaredConstructors = studentClass.getDeclaredConstructors();
  49.             for (Constructor<?> declaredConstructor1 : declaredConstructors) {
  50.                 System.out.println("declaredConstructor1= " + declaredConstructor1);
  51.             }
  54.         } catch (NoSuchMethodException e) {
  55.             e.printStackTrace();
  56.         }
  57.     }
  58. }

使用反射通过构造创建对象

  1. package com.powernode.p2;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.InvocationTargetException;
  6. /**
  7.  * 使用反射通过构造创建对象
  8.  *
  9.  */
  10. public class ConstructorDemo02 {
  11.     public static void main(String[] args) {
  12.         Class<Student> studentClass = Student.class;
  13.         try {
  14.             Constructor<Student> constructor = studentClass.getConstructor();
  15.             // 使用构造创建对象
  16.             /*
  17.             * newInstance(Object ... initargs)
  18.             *  参数表示使用构造创建对象的时候传入的实际参数
  19.             **/
  20.             Student student = constructor.newInstance();
  21.             System.out.println(student);
  23.             System.out.println("-------------------------------");
  24.             // public Student(String name, int age)
  25.             Constructor<Student> constructor1 = studentClass.getConstructor(String.class, int.class);
  26.             Student zhangsan = constructor1.newInstance("张三", 22);
  27.             System.out.println(zhangsan);
  29.             System.out.println("---------------------------");
  30.             //  private Student(String name)
  32.             Constructor<Student> declaredConstructor = studentClass.getDeclaredConstructor(String.class);
  33.             declaredConstructor.setAccessible(true);
  34.             Student lisi = declaredConstructor.newInstance("李四");
  35.             System.out.println(lisi);
  36.         } catch (NoSuchMethodException e) {
  37.             e.printStackTrace();
  38.         } catch (IllegalAccessException e) {
  39.             e.printStackTrace();
  40.         } catch (InstantiationException e) {
  41.             e.printStackTrace();
  42.         } catch (InvocationTargetException e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  46. }

使用反射获取方法信息

  1. package com.powernode.p2;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * 使用反射获取方法信息
  7.  *
  8.  * 反射机制就是将类的各个组成部分(属性，方法，构造器)封装为其它对象。
  9.  *
  10.  * 反射将方法的信息封装成Method对象
  11.  *
  12.  *
  13.  */
  14. public class MethodDemo01 {
  16.     public static void main(String[] args) {
  17.         try {
  18.             Class<?> aClass = Class.forName("com.powernode.p2.Student");
  19.             /*
  20.             * 获取指定的public方法,可以获取本类声明的，也可以获取继承父类的方法
  21.             * getMethod(String name, Class<?>... parameterTypes)
  22.             * 第一个参数表示方法的名字
  23.             * 第二个参数表示方法形参类型的Class
  24.             */
  25.             Method setName = aClass.getMethod("setName", String.class);
  26.             System.out.println(setName);
  28.             System.out.println("--------------------");
  29.             // 获取本类及父类的所有public方法
  30.             Method[] methods = aClass.getMethods();
  31.             for (Method method : methods) {
  32.                 System.out.println("method= " + method);
  33.             }
  35.             System.out.println("--------------------");
  36.             Method study = aClass.getDeclaredMethod("study");
  37.             System.out.println(study);
  38.         } catch (ClassNotFoundException e) {
  39.             e.printStackTrace();
  40.         } catch (NoSuchMethodException e) {
  41.             e.printStackTrace();
  42.         }
  44.     }
  45. }

使用反射执行方法

  1. package com.powernode.p2;
  3. import java.lang.reflect.InvocationTargetException;
  4. import java.lang.reflect.Method;
  6. /**
  7.  * 使用反射执行方法
  8.  *
  9.  */
  10. public class MethodDemo02 {
  11.     public static void main(String[] args) {
  13.         Class<Student> studentClass = Student.class;
  14.         try {
  15.             Method eatMethod = studentClass.getDeclaredMethod("eat", String.class);
  16.             // 调用方法
  17.             /*
  18.             * Object invoke(Object obj, Object... args)
  19.             * 第一参数表示执行哪一个对象的方法
  20.             * 第二参数表示调用方法传入的实参
  21.             *
  22.             * 返回值表示调用方法后方法的返回值
  23.             * void 返回就是null
  24.             *
  25.             */
  26.             eatMethod.setAccessible(true);
  27.             Object returnValue = eatMethod.invoke(studentClass.newInstance(), "狗粮");
  28.             System.out.println(returnValue);
  29.         } catch (NoSuchMethodException e) {
  30.             e.printStackTrace();
  31.         } catch (IllegalAccessException e) {
  32.             e.printStackTrace();
  33.         } catch (InstantiationException e) {
  34.             e.printStackTrace();
  35.         } catch (InvocationTargetException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  39. }

使用反射获取内部类 — 扩展

  1. package com.powernode.p2;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. public class InnerClassDemo {
  9.     public static void main(String[] args)  throws Exception{
  10. //       test01();
  11.         test02();
  12.     }
  14.     /*
  15.      * 演示成员内部类
  16.      */
  17.     private static void test02() throws Exception {
  18.         Class<Student> studentClass = Student.class;
  20.         // 获取内部类
  21.         Class<?>[] classes = studentClass.getClasses();
  23.         for (Class<?> aClass : classes) {
  24.             // aClass == Student$Inner
  25.             // public Student$Inner(Student this$0) {}
  26.             Constructor<?> constructor = aClass.getDeclaredConstructor(studentClass);
  27.             Object innerObj = constructor.newInstance(studentClass.newInstance());
  28.             // 调用内部类的方法
  29.             Method runMethod = aClass.getDeclaredMethod("run");
  31.             Object returnValue = runMethod.invoke(innerObj);
  32.             System.out.println(returnValue);
  34.             System.out.println("--------------------------");
  35.             Field[] declaredFields = aClass.getDeclaredFields();
  36.             for (Field declaredField : declaredFields) {
  37.                 System.out.println(declaredField);
  38.             }
  39.         }
  40.     }
  42.     /*
  43.     * 演示静态内部类
  44.     */
  45.     private static void test01()  throws Exception{
  46.         Class<Student> studentClass = Student.class;
  48.         // 获取内部类
  49.         Class<?>[] classes = studentClass.getClasses();
  50.         for (Class<?> aClass : classes) {
  51.             // 调用内部类的方法
  52.             Method runMethod = aClass.getDeclaredMethod("run");
  53.             Object returnValue = runMethod.invoke(aClass.newInstance());
  54.             System.out.println(returnValue);
  56.         }
  57.     }
  58. }