反射

reflection:java动态特性之一

动态语言

程序运行时，可以改变程序结构或者变量类型。

例如：Python、javascript语言，如下

  1. function  test{
  2.     var s="var a=3;var b=5;alert(a+b)";
  3.     eval(s);//eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。
  4. }

JAVA不是动态语言，但具有一定的动态性，可以利用反射机制、字节码操作获得类似动态语言的特性

反射机制:reflection

1、指的是在程序运行期间，可以加载一些任何你知道相关名称的类，可以让程序变得更加灵活。

2、程序在运行状态中，可以动态加载一个只有名称的类，对于任何一个已加载的类，都能够知道这个类的所有属性和方法，对于任何一个对象都能够调用它的任何方法和属性。

3、Class c=Class.forName(“包名.类名”);

Class对象

1、Class类：表示正在运行的java应用程序中的类和接口。和其他普通的类一样也具有实例化对象

2、Class对象：表示的是一些数据的封装，一个类被加载到JVM之后JVM会在堆内存中自动创建一个对应类的Class对象，类的整个结构信息会被放到对应的Class对象当中去。

3、Class对象就像是一面镜子，通过这面镜子可以看到对应类的全部信息，所以称为反射。

4、一个类只有一个Class对象：类只会被加载一次，加载一次后产生一个Class对象。

获取Class对象的方法

①、类.class

  1. //获取String类的对象
  2. Class clazz=String.class;

②、Class clazz=Class.forName(“包名.类名”);

③、其他类的对象.getClass()

  1. //通过String类的对象path获取
  2. String path=“扒鸡”；
  3. Class claz=path.getclass();

常见作用

一、动态加载类、动态获取类的信息（属性、方法、构造器）

①、动态加载类

  1. String path="study.Student";
  2. Class claz=Class.forName(path);

②、获取类名

  1. claz.getSimpleName()；

③、public属性

  1. claz.getFields();

④、所有属性

  1. claz.getDeclaredFields();

⑤、指定名称的属性

  1. claz.getDeclaredField("name");

⑥、类的所有方法

  1. claz.getDeclaredMethods();

⑦、方法名和参数类的某个方法

  1. Method med=claz.getDeclaredMethod("getName",null);

⑧、获取构造方法信息

  1.  Constructor[] constructors= claz.getConstructors(); //获得所有构造器
  2.     for (Constructor temp:constructors
  3.          ) {
  4.         System.out.println("构造方法："+temp);
  5.     }

⑨、获取指定参数的构造器

  1. Constructor constructor=claz.getDeclaredConstructor(int.class,String.class,int.class);
  2. System.out.println(constructor);

Demo代码

  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/10/15 15:26.
  4.  * 通过反射获取类的结构信息
  5.  */
  6. public class ReflectionDemo01 {
  7.     public static void main(String[] args) {
  8.         String path="study.Student";
  9.         try {
  10.             Class claz=Class.forName(path);
  11.             System.out.println(claz.getSimpleName());//获得类名：Student
  12.             //获得属性信息
  13.             Field[]fields=claz.getFields();     //只能获得public的属性
  14.             System.out.println(fields.length);
  15.             fields=claz.getDeclaredFields();    //获得所有的属性
  16.             System.out.println(fields.length );
  17.              Field fd=claz.getDeclaredField("name");//获得指定名字的属性
  18.              System.out.println(fd.getName());
  19.             for (Field temp:fields
  20.                  ) {
  21.                 System.out.println("属性："+temp);
  22.             }
  23.             //获取类的方法的信息
  24.             Method[] method=claz.getDeclaredMethods();  //获得所有方法
  25.             Method med=claz.getDeclaredMethod("getName",null);//通过方法名和参数获得类的某个方法，参数用于重载。
  26.             System.out.println("getName方法："+med);
  27.             for (Method temp:method
  28.                  ) {
  29.                 System.out.println("方法："+temp);
  30.             }
  31.             //获取构造方法信息
  32.             Constructor[] constructors= claz.getConstructors(); //获得所有构造器
  33.             for (Constructor temp:constructors
  34.                  ) {
  35.                 System.out.println("构造方法："+temp);
  36.             }
  37.             //获取指定参数的构造器
  38.             Constructor constructor=claz.getDeclaredConstructor(int.class,String.class,int.class);
  39.             System.out.println(constructor);
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  44. }

动态构造对象

①、调用无参构造器，并且实例化对象

  1. claz.getConstructor().newInstance();

②、有参构造器、实例化对象

  1. Constructor<Student>c=claz.getDeclaredConstructor(int.class,String.class,int.class);
  2. Student s=c.newInstance(001,"扒鸡1号",32);

获取方法对象

  1. claz.getDeclaredMethod
  2.             +
  3. invoke(Object obj, Object... args) 
  5. //通过反射API调用普通方法
  6. Student s2=(Student)claz.getConstructor().newInstance();
  7. //获得方法对象
  8. Method method=claz.getDeclaredMethod("setName", String.class);
  9. method.invoke(s2,"扒鸡2号");   //s2.setName("扒鸡2号");
  10. System.out.println(s2.getName());

动态调用和处理属性（私有）

  1. 1、获取Field对象：claz.getDeclaredField("name");
  2. 2、禁用安全检查：.setAccessible(true);
  3. 3、操作私有属性：.set(s3,"扒鸡3号");
  5. //通过反射API动态的操作属性（私有）
  6. Student s3=(Student) claz.getConstructor().newInstance();
  7. Field field=claz.getDeclaredField("name");
  8. field.setAccessible(true);//表示这个属性不用做安全检查，直接可以访问
  9. field.set(s3,"扒鸡3号");   //通过反射直接写属性
  10. System.out.println(field.get(s3));  //通过反射读属性

Demo代码

  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/10/15 17:47.
  4.  * 通过反射API动态的操作：构造器、方法、属性
  5.  * 动态调用和处理属性
  6.  */
  7. public class ReflectionDemo02 {
  8.     public static void main(String[] args) {
  9.         String path="study.Student";
  10.         try {
  11.             Class claz=Class.forName(path);
  12.             Student student=(Student)claz.getConstructor().newInstance();//调用Student的无参构造器，并且实例化
  13.             System.out.println(student);
  14.             //调用有参构造器、实例化对象
  15.             Constructor<Student>c=claz.getDeclaredConstructor(int.class,String.class,int.class);
  16.             Student s=c.newInstance(001,"扒鸡1号",32);
  17.             System.out.println(s.getName());
  18.             //通过反射API调用普通方法
  19.             Student s2=(Student)claz.getConstructor().newInstance();
  20.             //获得方法对象
  21.             Method method=claz.getDeclaredMethod("setName", String.class);
  22.             method.invoke(s2,"扒鸡2号");   //s2.setName("扒鸡2号");
  23.             System.out.println(s2.getName());
  24.             //通过反射API动态的操作属性（私有）
  25.             Student s3=(Student) claz.getConstructor().newInstance();
  26.             Field field=claz.getDeclaredField("name");
  27.             field.setAccessible(true);//表示这个属性不用做安全检查，直接可以访问
  28.             field.set(s3,"扒鸡3号");   //通过反射直接写属性
  29.             System.out.println(field.get(s3));   //通过反射读属性
  30.         } catch (Exception e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }

java泛型机制

java采用泛型擦除机制来引入泛型。java中的泛型仅仅是给编译器使用的，确保数据的安全性和免去强制类型转换的麻烦。在编译之后程序会采取 去泛型化 的措施。也就是说，只在编译期间有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说：泛型信息不回进入运行阶段，也就是说：泛型类型在逻辑上看成是多个不同的类型，实际上都是相同的基本类型。

反射操作泛型

为了迎合开发的需要。java新增了几种类型来保存泛型的信息

反射操作泛型

1、ParameterizedType：表示一种参数化的类型，比如Collection

2、GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型

3、TypeVariable：表示各种类型变量的的公共父接口

4、WildcardType：代表通配符类型表达式

反射操作注解

步骤：
①、获取对应类或者类的方法或者类的属性的Class对象

②、通过Class对象.getAnnotation（”注解名”）方法获取注解

Demo代码

  1. /**
  2.  * @auther TongFangPing
  3.  * @date 2019/10/14 22:53.
  4.  * 使用反射读取注解的信息
  5.  * 通过反射获取类、类的属性、累的方法中的注解，可以用来拼接成SQL语句。
  6.  */
  7. public class Demo {
  8.     public static void main(String[] args) {
  9.         try {
  10.             //反射获取Class对象
  11.              Class claz=Class.forName("com.annotate.study.Student");
  12.              //获取Student类的所有注解
  13.              Annotation[] annotations=claz.getAnnotations();
  14.             for (Annotation aos:annotations
  15.                  ) {
  16.                 System.out.println(aos);
  17.             }
  18.             //获取类的指定注解
  19.             TableAnnotation tban= (TableAnnotation)claz.getAnnotation(TableAnnotation.class);
  20.             System.out.println(tban.value());
  21.             //获得类的属性的注解
  22.             Field  field =claz.getDeclaredField("name");
  23.             FileldAnnotation fdAn=field.getAnnotation(FileldAnnotation.class);
  24.             System.out.println(fdAn.columnName()+"--"+fdAn.type()+"--"+fdAn.length());
  25.             //根据获得的表名、字段的信息、拼出SQL语句，使用JDBC执行，生成数据表
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30. }