反射机制--总结

首页 > 代码库 > 反射机制--总结

2024-09-15 03:59:43 220人阅读

1.反射的概念：

Reflection(反射) 被视为动态语言的关键，反射机制允许程序在执行的时候借助Reflection的API 获取任何类的内部信息，直接操作任何对象的内部属性和方法。

技术分享

2.Object类中定义Class 类：反射从程序允许结果看：利用Java编译生成.class文件反编译原来的Java---通过对象反射求出类的名称

1). 反射的理解：反射通过动态的设置内部的属性和方法，在反射的过程中，我们事先不知道类的名称是什么，采用getClass() 方法获取一个实体的类型---在JavaBean过程中反射的类必须有一个无参的构造器：同时在反射的时候属性和方法的名称保持一致

对getClass（）: Object 类一个方法名叫getClass，利用该方法获取一个实例的类型类类型类指的是代表一个类型的类，String类型的类String.class

java 中所有的类型类是Class的实体

getClass（）：一个类的实例具备的方法.getClass() 是动态的；解释：返回这个对象正在运行是的类，直到这个对象属于什么类

Class（）方法是一个类的方法是静态的方法

总结：

1. 对Class 实例的理解

正常情况：创建一个类，通过编译（javac.exe）,生成对应的class文件，之后使用Java.exe(JVm 类加载器)运行.class 文件

反射情况：此class文件加载到内存以后就是一个运行时类 , 存在缓存区域，那么此运行时类就是一个Class 的实例；对某个对象.getClass() 为了得到这个运行时类注意每一个运行类只加载一次 Person.Java--编译--Person.class(Class 的实例)

2.获取Class 实例 clazz作用：

1）.创建对应的运行时类的对象 clazz.newInstance();

技术分享

2).对应运行时类的完整结构

3）.调用指定的属性，方法和构造器

4）.反射的应用动态的代理

1.Java中有四种方法获取反射的机制：

1.调用运行时类的本身的.class的属性：静态

Class clazz=Person.class;

2.通过运行时对象获取：动态

Person per=new Person（）；

Class clazz=per.getClass();

3. 通过Class 的静态的方法

Class.forName("com.atug.Person");

4.通过类的加载器

Class clazz=this.getClass().getClassLoader().loadClass("com.atug.Person");

 1    Person person=new Person();
 2         // 1.第一种方式通过Object的getClass() 方法（需要实例化一个对象）
 3         Class clazz1=person.getClass();
 4         
 5         // 2.通过对象实例方法获取（需要实例化一个对象）
 6         Class clazz2=Person.class;
 7         
 8         // 类的全路径
 9         try {
10             Class clazz3=Class.forName("com.atug.reflection_1.Person");
11         } catch (ClassNotFoundException e) {
12             // TODO Auto-generated catch block
13             e.printStackTrace();
14         }
15

技术分享

2.Class 实例第一种作用：

2.1创建类的对象：调用Class对象的new Instance（）的方法：

1）类必须误差构造器 2）.类的构造器的访问权限必须足够

反射类没有空的构造器，报错；类的构造器是非private权限

技术分享

通过反射获取对象的内部成员的属性，不理睬private

 1 // 1.第一种方式通过Object的getClass() 方法（需要实例化一个对象）
 2           Class clazz=Person.class;
 3         
 4           5          //.getFields 只能获取其中 public属性
 6           Field[] fields=clazz.getDeclaredFields();
 7         
 8           for(Field fi:fields)
 9           {
10               System.out.println(fi.getName());
11           }
12           
13           //同样获取运行的方法
14           Method[] m1=clazz.getDeclaredMethods();
15           for(Method m:m1)
16           {
17               System.out.println(m.getName());
18           }
19

技术分享

事实上：利用反射的主要目的不在获取内部属性或者是内部方法名称在于利用反射动态的建立一个对象，在其中设置成员属性和调用其中成员方法

2.2. 因此首先反射动态的建立一个类的对象 Person p=clazz.newInstance(); 调用类型方法时候注意private 同时Method.invoke() 启动反射建立的实例的方法

 1  // 利用反射的主要目的不在获取内部属性或者是内部方法名称 在于利用反射动态的建立一个对象，在其中设置成员属性和调用其中成员方法
 2           // 1.利用反射调用指定的属性  私有成员Declared
 3           Person p=(Person) clazz.newInstance();
 4           Field f1=clazz.getDeclaredField("name");
 5           f1.setAccessible(true);
 6           f1.set(p,"HuHui");
 7           System.out.println(p);
 8           
 9           // 2.利用反射生成某个实例调用其中的方法 paramterTypes=show 类型 void null
10           Method M1=clazz.getDeclaredMethod("show");
11           M1.setAccessible(true);
12           M1.invoke(p);

4.对加载器的理解：

程序主动使用某个类的时候，该类没有被加载到内存，使用getClassLoader().loadClass();

技术分享

类加载器将类加载到内存：启动型加载器和自定义加载器

Java核心库String是引导类加载器

技术分享

使用类加载器从某个目录下得得到 properties

 1 ClassLoader loader1=this.getClass().getClassLoader();
 2         System.out.println(loader1);
 3         // 类加载器加载某个目录下的Java
 4         InputStream is=loader1.getResourceAsStream("com\\atug\\properties");
 5         // 当前工作空间小
 6         FileInputStream in=new FileInputStream(new File("jdbc.properties"));
 7         Properties pro=new Properties();
 8         pro.load(is);
 9         
10         String name=pro.getProperty("XXX");
11     }

3.反射第二个事情：反射获取类的完整的结构：实现全部接口，所继承的父类全部的Field

常用反射获取泛型的类型

3.1 获取属性，获取权限修饰符变量类型变量名

 1         Class clazz=Person.class;
 2         
 3         //Person 类比较的复杂继承 和泛型接口
 4         Field [] fields=clazz.getFields();
 5         
 6         // 查看一下getFields 只能获取运行本类和父类中声明public属性 null
 7         for(Field field:fields)
 8         {
 9             System.out.println(field.getName());
10         }
11         
12         // 2. 获取所有声明的属性，如果修改属性值必须field.setAccessible(arg0);
13         Field [] fields1=clazz.getDeclaredFields();
14         for(Field field:fields1)
15         {
16             
17             System.out.println(field);
18             
19             System.out.println(field.getName());
20             // 1.获取修饰符
21             System.out.println(Modifier.toString(field.getModifiers()));
22             
23             // 2.获取属性的类型：
24             Class Type=field.getType();
25             System.out.println(Type.getName());

技术分享

3.2 获取运行时候的父类---发现得到父类的名称父类有泛型并没有显示出来

1 Class clazz=Person.class;
2         
3         Class superClass=clazz.getSuperclass();
4         System.out.println(superClass.getName());

技术分享

3.3 获取带泛型的父类父类的类型： getGenericsuperClass();获取父类泛型--返回Type类型

 1 Class clazz=Person.class;
 2         Type type=clazz.getGenericSuperclass();
 3         
 4         System.out.println(type);
 5         
 6         //--------重点：获取父类的泛型 String-----
 7         // ParameterizedType 是Type的子类 --带有参数化的Type
 8         
 9         if(type instanceof ParameterizedType)
10         {
11              ParameterizedType param=( ParameterizedType)type;
12              
13              // 获取带参数Type 中实际参数类型 返回数组有多个参数 
14              Type[] types=param.getActualTypeArguments();
15              if(types[0] instanceof Class)
16                     System.out.println(types[0].getTypeName());
17         }

技术分享

DAO 直到操作的那个类，获取父类的泛型反射建立对象将SQL中数据存到JavaBean中。

反射机制--总结

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 反射机制--总结

反射机制--总结

看完仍有疑问？有类似问题直接问程序猿