下载文档原格式
Java中的反射机制详解Java作为一种编程语言，具有许多强大的特性和功能。
其中，反射机制是其中的重要部分之一。
通过反射机制，Java程序可以在运行时动态地获取类的信息、构造对象、调用方法和访问属性等。
本文将详细介绍Java中的反射机制。
一、什么是反射机制？Java中的反射机制指的是在程序运行时动态获取类的信息并对其进行操作的能力。
通过反射机制，Java程序可以在运行时获取类的属性、方法和构造器等信息，并对其进行操作。
利用反射机制可以实现动态代理、框架开发、自动化测试等功能。
二、反射机制的基本原理Java程序在编译时会将类的信息编译成.class文件。
在程序运行时，JVM会将.class文件加载到内存中，并生成一个Class对象，该对象包含了类的所有信息。
通过Class对象，Java程序可以获取类的构造器、方法、属性等信息，并对它们进行操作。
三、反射机制的使用Java中的反射机制主要通过ng.reflect包中的类和接口实现。
在这个包中，最常用的类包括Class、Constructor、Method和Field等。
下面我们将分别介绍这些类的用法。
1、Class类Class类是Java中用来表示类的类。
在Java程序中，每个类都有一个对应的Class对象，可以使用该对象获取类的信息。
获取Class对象有以下三种方式：（1）使用类的.class属性获取：Class clazz = MyClass.class;（2）使用Class的forName()方法获取：Class clazz = Class.forName("com.example.MyClass");（3）使用对象的getClass()方法获取：MyClass obj = new MyClass();Class clazz = obj.getClass();通过Class对象可以获取类的信息，如：（1）类的名称：String name = clazz.getName(); // com.example.MyClass（2）类的简单名称：String simpleName = clazz.getSimpleName(); // MyClass（3）类的包路径：Package pkg = clazz.getPackage(); // com.example（4）类的修饰符：int modifiers = clazz.getModifiers(); // 返回访问修饰符列表（5）类的父类：Class superClass = clazz.getSuperclass(); // 返回父类的Class对象2、Constructor类Constructor类用于描述类的构造器。
Java 反射一、Java 语言的反射机制在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。
这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。
Java 反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法Reflection 允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces （例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。
那么反射这么厉害，java是不是动态语言呢？来看一下动态语言百科上的定义：动态语言，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。
从这个角度看很明显，发现java不是动态语言尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。
这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。
换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或调用其methods。
二、Java Reflection API 简介在JDK中，主要由以下类来实现Java反射机制，这些类都位于ng.reflect包中Class类：代表一个类。
首页资讯精华论坛问答博客专栏群组更多 ▼您还未登录 !登录注册jczghost博客微博相册收藏留言关于我java反射机制总结博客分类：java-高级JavaStrutsBean框架Mobile经过多方面的资料搜集整理，写下了这篇文章，本文主要讲解java的反射和内省机制，希望对大家有点帮助,也希望大家提出不同的看法！1).反射是java的基础技术，在我们用到的框架如:struts,spring,hibernate,junit等都用到了反射技术，所以了解反射对我们来说也很重要。
要了解反射技术，必须要了解一个类Class类。
2).平时我们定义class的时候都是小写，这里讲的Class是大写，此时它代表一类事物，java类用于描述一类事物的共性，如该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定，不同的事物对象有不同的属性值。
java程序中的java类，属于同一类事物，描述这类事物的Java类名就是Class.，就比如众多的人可以用一个Person类表示一样，众多的java类用Class来表示。
3).Class类代表Java类，它(Class类)的各个实例对象分别对应各个类在内存中的字节码，那么什么叫字节码呢? java源程序被编译成一堆二进制的class代码，当我们需要用到某个类时，首先把类的字节码加载到内存中来，然后再用该字节码去复制一个个的实例对象来，每份字节码都是Class类的实例对象，即Class类的实例对象就代表内存中字节码。
如：public static void main(String[] args) throws Exception {Class cls1 = Date.class;//cls1代表Date类在内存中的字节码Class cls2 = String.class;//cls2代表String类在内存中的字节码Class cls3 = String.class;//cls3代表String类在内存中的字节码System.out.println(cls2 == cls3);//true:同一份字节码在内存中的地址相同}4).一个类被类加载器加载到内存中，占用一片存贮空间，这个空间里的内容就是这个类的字节码，不同的类的字节码是不同的,所以它们在内存中的内容是不同的，这一个个的空间分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class类型.5).如何得到各个字节码对应的实例对象?(Class类型):即得到字节码的三种方式：.)类名.class 例如：System.class//写程序的时候就知道类的名称.)对象.getClass() 例如：new Date().getClass().)Class.forName() 例如：Class.forName("java.util.Date");//类的字符串的完整名称做反射的时候常用第三种,因为写源程序的时候不知道类的名称,在运行的时候根据传递的字符串来创建.例如：public static void main(String[] args) throws Exception {Date nowDate = new Date();Class cls1 = nowDate.getClass();//getClass()方法返回创建该对象的字节码Class cls2 = Date.class;Class cls3 = Class.forName("java.util.Date");System.out.println(cls1);// class java.util.DateSystem.out.println(cls1 == cls2);// trueSystem.out.println(cls1 == cls3);// true//这说明三个应用变量引用的是同一份字节码}例如：public static void main(String[] args) throws Exception {Date nowDate = new Date();Date tomDate = new Date();System.out.println(nowDate == tomDate);// falseSystem.out.println(nowDate.getClass() == tomDate.getClass());// true//同一个类的字节码是相同的(即使是不同的实例对象.getClass()依然是相等的).}6)Class.forName()的作用:得到这个类的字节码，包含下面两种情况.这个类的字节码已经加载到Java虚拟机中，只需要找到返回..这个类的字节码在Java虚拟机没找到，于是用类加载器加载，然后把类的字节码缓存起来再返回..7)8个基本类型和一个void共9个预定义的Class实例对象例如:public static void main(String[] args) throws Exception {System.out.println(int.class.isPrimitive());//trueSystem.out.println(int.class == Integer.class);//falseSystem.out.println(int.class == Integer.TYPE);//true,TYPE表示基本类型 Class实例。
java-反射机制txt.txt25爱是一盏灯，黑暗中照亮前行的远方；爱是一首诗，冰冷中温暖渴求的心房；爱是夏日的风，是冬日的阳，是春日的雨，是秋日的果。
反射使您的程序代码能够接入装载到JVM中的类的内部信息，允许您编写与执行时，而不是源代码中选定的类协作的代码。
这使反射成为构建灵活的应用的主要工具。
但需注意的是-- 如果使用不当，反射的成本很高。
在Java平台系列的第2部分中，软件顾问Dennis Sosnoski介绍了如何使用反射，以及某些相关的成本。
您还将找到Java Reflection API如何使您能够在运行时关联对象。
在“Java 编程的动态性，第1部分，”我为您介绍了Java编程类和类装入。
该篇文章介绍了一些Java二进制类格式的相关信息。
这个月我将阐述使用Java反射API来在运行时接入和使用一些相同信息的基础。
为了使已经熟知反射基础的开发人员关注本文，我将在文章中包括反射性能如何与直接接入相比较。
使用反射不同于常规的Java编程，其中它与元数据--描述其它数据的数据协作。
Java语言反射接入的特殊类型的原数据是JVM中类和对象的描述。
反射使您能够运行时接入广泛的类信息。
它甚至使您能够读写字段,调用运行时选择的类的方法。
反射是一种强大的工具。
它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。
但反射的某些方面存在一些疑问。
在本文中，我将深入讨论为什么您可能不希望在程序中使用反射，以及您应该这样做的理由。
在了解了权衡性分析之后，您可以自行决定是否利大于弊。
初学者的类使用反射的启点总是ng.Class实例。
如果您希望与预先定义的类协作，那么Java语言提供一种直接获得Class实例的简便快捷方式：第1部分，“类和类装入”代码:Class clas = MyClass.class;当您使用这一项技术时，装入类涉及的所有工作在幕后进行。
但是，如果您需要在运行时从某些外部源读取类名，这种方法并不适合。
java反射使用案例Java反射是指在运行时动态地获取一个类的信息，包括类的构造方法、字段、方法等，并能够在运行时调用类的方法或操作类的属性。
通过反射，我们可以在运行时获取类的信息并进行动态操作，实现了面向对象编程的灵活性和可扩展性。
下面将介绍十个使用Java反射的案例。
1. 获取类的信息通过反射可以获取一个类的各种信息，如类的名称、修饰符、父类、实现的接口等。
可以使用Class类提供的方法来获取这些信息，如getName()、getModifiers()、getSuperclass()等。
2. 创建对象通过反射可以在运行时动态地创建一个类的对象，即使在编译时并不知道具体的类名。
可以使用Class类的newInstance()方法来创建对象，或者通过Constructor类的newInstance()方法来创建对象。
3. 调用方法通过反射可以在运行时动态地调用一个类的方法，即使在编译时并不知道具体的方法名和参数类型。
可以使用Method类提供的方法来调用方法，如invoke()方法。
4. 修改字段的值通过反射可以在运行时动态地修改一个类的字段的值，即使在编译时并不知道具体的字段名和字段类型。
可以使用Field类提供的方法来修改字段的值，如set()方法。
5. 获取构造方法通过反射可以获取一个类的所有构造方法，包括公有构造方法和私有构造方法。
可以使用Class类提供的方法来获取构造方法，如getConstructors()方法和getDeclaredConstructors()方法。
6. 获取字段通过反射可以获取一个类的所有字段，包括公有字段和私有字段。
可以使用Class类提供的方法来获取字段，如getFields()方法和getDeclaredFields()方法。
7. 获取方法通过反射可以获取一个类的所有方法，包括公有方法和私有方法。
可以使用Class类提供的方法来获取方法，如getMethods()方法和getDeclaredMethods()方法。
Java反射机制的应用场景1. 什么是Java反射机制Java反射机制是指在运行时动态地获取类的信息并操作类和对象的能力。
通过反射，我们可以在运行时动态地创建对象、调用方法、访问字段等，使得程序具备更高的灵活性和扩展性。
Java反射机制提供了一套API，包括Class、Constructor、Method、Field等等。
通过这些API，我们可以获取类的类型信息，创建对象，调用方法，访问字段等。
2. 反射机制的应用场景Java反射机制具有广泛的应用场景，下面将介绍一些常见的应用场景。
2.1. 动态创建对象反射机制可以在运行时动态地创建对象，这在某些情况下非常有用。
例如，当我们需要根据配置文件或用户输入来决定创建哪个对象时，就可以使用反射来实现。
使用反射创建对象的步骤如下： 1. 获取类的Class对象； 2. 调用newInstance()方法创建对象。
class MyClass {public MyClass() {// ...}}Class<?> cls = MyClass.class;MyClass obj = (MyClass) cls.newInstance();2.2. 动态调用方法反射机制还可以在运行时动态地调用对象的方法。
这在需要根据条件来决定调用哪个方法时非常有用。
使用反射调用方法的步骤如下： 1. 获取类的Class对象； 2. 获取方法的Method 对象； 3. 调用invoke()方法调用方法。
class MyClass {public void sayHello() {System.out.println("Hello!");}}Class<?> cls = MyClass.class;MyClass obj = new MyClass();Method method = cls.getMethod("sayHello");method.invoke(obj);2.3. 动态访问字段反射机制还可以在运行时动态地访问对象的字段。
java反射机制代码例子Java反射机制是Java语言的一个强大特性，它允许程序在运行时动态地获取类的信息，调用对象的方法和构造方法，甚至可以访问和修改对象的属性。
下面是一个简单的Java反射机制代码例子，以展示如何使用Java反射机制获取类的信息并动态地创建对象：```import ng.reflect.Constructor;import ng.reflect.Field;import ng.reflect.Method;public class ReflectionExample {public static void main(String[] args) throws Exception { // 获取Person类的Class对象Class<?> clazz = Class.forName('Person');// 获取Person类的所有构造方法Constructor<?>[] constructors =clazz.getDeclaredConstructors();// 输出Person类的所有构造方法System.out.println('Person类的所有构造方法:');for (Constructor<?> constructor : constructors) {System.out.println(constructor);}// 获取Person类的所有属性Field[] fields = clazz.getDeclaredFields();// 输出Person类的所有属性System.out.println('Person类的所有属性:');for (Field field : fields) {System.out.println(field);}// 获取Person类的所有方法Method[] methods = clazz.getDeclaredMethods();// 输出Person类的所有方法System.out.println('Person类的所有方法:');for (Method method : methods) {System.out.println(method);}// 使用反射机制动态创建Person对象Object person = constructors[1].newInstance('Tom', 20); // 使用反射机制调用Person对象的方法Method method = clazz.getDeclaredMethod('sayHello');method.invoke(person);}}class Person {private String name;private int age;public Person() {}public Person(String name, int age) { = name;this.age = age;}public void sayHello() {System.out.println('Hello, my name is ' + name + ', I'm ' + age + ' years old.');}}```在上述代码中，我们首先使用`Class.forName()`方法获取`Person`类的`Class`对象，然后分别使用`getDeclaredConstructors()`、`getDeclaredFields()`和`getDeclaredMethods()`方法获取`Person`类的构造方法、属性和方法信息。
Java中类加载和反射技术实例我们知道⼀个对象在运⾏时有两种类型，⼀个是编译类型，⼀个是运⾏时类型。
在程序运⾏时，往往是需要发现类和对象的真实的信息的。
那么如何获的这种信息呢？其⼀，如果我们在编译和运⾏时都知道类型的具体信息，这时是可以⼿动将⼀个对象转换为运⾏时的类型。
其⼆，如果我们在编译时⽆法预知对象和类到底是属于哪些类，那么程序只有依靠运⾏时的信息来发现对象和类的真实的信息了，这时就必须要⽤到反射技术。
在谈具体的反射技术之前，我想先回顾下，有关类的加载的⼀些基本的性质和原理，以⽅便我们更好地理解，反射的作⽤和特点。
⽽实际上，⼀个类如果可以被执⾏，那么对于JVM来说，它的执⾏流程为：类的加载、连接、初始化。
通过这种⽅式，才可以获取到⼀个类的类对象，即ng.Class对象，并在此基础上获取到该类的成员变量，⽅法和构造器等内在的东东。
那么，什么是类的加载呢？类的加载就是将类的class⽂件读⼊内存，并为之创建⼀个ng.Class对象，也就是说当程序使⽤任何类时，系统都会为之建⽴⼀个ng.Class对象。
同时，这个ng.Class对象⼜有什么特点呢？1、Class是⼀个类，⼀个描述类的类（也就是描述类本⾝），封装了描述⽅法的Method，描述字段的Filed，描述构造器的Constructor等属性2、对象照镜⼦后（反射）可以得到的信息：某个类的数据成员名、⽅法和构造器、某个类到底实现了哪些接⼝。
3、对于每个类⽽⾔，JRE 都为其保留⼀个不变的 Class 类型的对象。
⼀个 Class 对象包含了特定某个类的有关信息。
4、Class 对象只能由系统建⽴对象5、⼀个类在 JVM 中只会有⼀个Class实例同时，我们了解下⼀个基本的类加载器的结构：类的连接：连接阶段负责把类的⼆进制数据合并到JRE中，分为三个步骤：第⼀，验证，检验被加载的类是否有正确的内部结构；第⼆，准备，负责为类的类变量分配内存，并设置默认初始值。
JAVA中的反射机制Java的反射机制是指在程序运行时，可以动态地获取一个类的信息，并且可以通过反射在运行时动态地调用和操作类的方法、属性、构造方法等。
反射机制使得Java具备了一定的动态性，可以在运行时动态地加载、创建和操作对象，开发出更加灵活和通用的代码。
本文将详细介绍Java的反射机制，包括反射的基本概念、如何获取类的信息、如何调用类的方法、如何操作类的属性以及如何动态创建对象等。
1.反射的基本概念反射是Java语言的一种机制，它可以在运行时动态地获取和操作一个类的信息。
在Java中，每一个类都对应一个Class对象，该对象包含了类的所有信息，比如类的名称、字段、方法等。
通过反射，可以在程序运行时动态地获取并操作一个类的Field、Method、Constructor等。
2.获取类的信息在Java中，可以通过Class类的静态方法forName(来获取一个类的Class对象。
例如，要获取String类的Class对象，可以使用以下代码：Class<?> cls = Class.forName("ng.String");通过Class的静态方法forName(可以根据类的全限定名获取该类的Class对象，但是需要注意的是，要使用全限定名来获取Class对象。
如果需要获取数组类型的Class对象，则可以使用Class类的静态方法forName(，并在类名后加上"[]"表示。
3.调用类的方法通过反射机制，可以在运行时动态地调用一个类的方法。
首先，需要获取Method对象，然后使用Method对象的invoke(方法来调用方法。
下面是一个示例代码：Class<?> cls = Class.forName("ng.String");Object obj = cls.newInstance(; //创建类的实例Method method = cls.getMethod("length"); //获取方法对象Object result = method.invoke(obj); //调用方法int length = (int) result; //获取调用结果System.out.println(length); //输出结果4.操作类的属性通过反射机制，还可以在运行时动态地操作一个类的属性。
Java语言中的反射机制Java是一种优秀的编程语言，拥有着强大的功能和广泛的应用。
其中反射机制是Java语言的一个重要特性，它使得程序员可以在运行时借助Java程序来探索、分析和修改程序的内部结构。
本文将介绍Java反射机制的原理、用法和注意事项等方面内容。
一、什么是反射机制？反射机制是指Java程序在运行时能够动态地获取和检查一个类的属性、方法和构造函数等信息，并且可以在运行时修改这些元素的值或行为。
在Java中，每一个类都有反射对象，反射对象可以通过Java反射API来访问和操作。
Java反射API提供了一系列的类和方法，使得程序员能够在运行时动态地加载、访问、使用和操作Java类。
二、Java反射机制的应用Java反射机制可以用在很多方面。
例如，当代码需要在运行时动态地加载一个类时，就需要使用反射机制。
当需要实现动态代理时，反射机制也是必不可少的。
Java的注解机制也必须借助反射机制来实现。
下面我们将具体介绍Java反射机制的常见应用：1. 动态加载类和调用方法Java反射机制可以在运行时动态地创建一个类的实例、访问类的静态变量、调用成员方法等操作。
例如，可以使用Java反射机制创建一个类的对象，并在运行时调用类中的方法，如下所示：Class clazz = Class.forName("com.example.MyClass");Method method = clazz.getDeclaredMethod("myMethod");Object object = clazz.newInstance();method.invoke(object);上述代码中，首先通过Class.forName方法获取类com.example.MyClass的Class对象，然后使用getDeclaredMethod 方法获取myMethod方法的Method对象。
java的反射原理宝子！今天咱们来唠唠Java里超级有趣又有点神秘的反射原理。
你可以把Java的反射想象成是一个超级侦探。
在Java的世界里呢，正常情况下，我们都是按照常规的方式去使用类和对象的。
就像是你每天走同一条路去上班或者上学，规规矩矩的。
但是反射呢，它就像是发现了一条秘密通道，可以在运行的时候，去探索那些我们原本只能在代码编写时才知道的类的信息。
比如说，有一个类就像一个神秘的城堡，里面有好多宝藏（成员变量、方法啥的）。
正常情况下，我们只能从大门（常规的类使用方式）进去拿东西。
但是反射这个小机灵鬼，它可以绕到城堡的后面，找到一些隐藏的入口，然后悄悄地进去查看宝藏。
那它是怎么做到的呢？在Java里，每个类在运行的时候都有一个对应的Class对象。
这个Class对象就像是这个类的身份证一样，上面记录着这个类的所有信息。
反射就是通过获取这个Class对象，然后开始它的探秘之旅的。
当我们想要使用反射去操作一个类的时候，就好像我们在和这个类玩一个猜谜游戏。
我们可以通过类的名字，就像喊出这个类的名字一样，然后Java就会找到这个类对应的Class对象。
比如说，有个类叫MyClass，我们可以用Class.forName("MyClass")这样的方式来获取它的Class对象。
这就像是在一个满是人的房间里，大喊一声“谁是MyClass”，然后那个代表MyClass的家伙就会站出来。
一旦拿到了这个Class对象，哇塞，那就像拿到了城堡的地图一样。
我们可以通过这个Class对象去查看这个类里有哪些成员变量。
就好比在城堡里找宝箱，我们可以用getFields()或者getDeclaredFields()这样的方法。
getFields()就像是找那些公开摆放的宝箱，大家都能看到的；而getDeclaredFields()呢，就像是找那些隐藏起来的宝箱，只有这个城堡内部知道的。
同样的，对于方法也是这样。
Java反射的常用案例Java反射是一种强大的工具，允许在运行时检查和修改类、接口、字段和方法。
以下是一些Java反射的常用案例：1.获取类的信息：使用反射，可以获取类的名称、包名、注释等。
Java：Class<?> clazz = String.class;System.out.println("Class Name: " +clazz.getName());System.out.println("Package Name: " +clazz.getPackage().getName());2.获取和修改字段：反射允许您获取类的所有字段，包括私有字段，并修改它们的值。
Java：public class Person {private String name;public String getName() { return name; }public void setName(String name) { = name; }}Person person = new Person();person.setName("John");Class<?> clazz = person.getClass();Field nameField = clazz.getDeclaredField("name");nameField.setAccessible(true); // 设置为可访问，因为它是私有的nameField.set(person, "Doe"); // 修改字段的值System.out.println(person.getName()); // 输出: Doe3.调用方法：使用反射，可以调用任何方法，包括私有方法。
Java：public class Person {public void sayHello() {System.out.println("Hello!");}}Person person = new Person();Class<?> clazz = person.getClass();Method sayHelloMethod =clazz.getDeclaredMethod("sayHello");sayHelloMethod.setAccessible(true); // 设置为可访问，因为它是私有的sayHelloMethod.invoke(person); // 调用方法4.创建对象：使用反射，可以在运行时动态地创建对象。
了解Java中的反射机制及其应用场景反射机制是Java语言中一种强大的特性，它允许程序在运行时动态地获取和操作类的信息，包括类的构造方法、成员变量、方法等。
通过反射，我们可以在编译时无需知道类的具体信息，在运行时动态地加载和使用类。
本文将介绍Java中的反射机制及其应用场景。
一、反射机制的基本原理Java的反射机制允许程序在运行时检查和操作类的方法、属性和构造函数等信息。
它的基本原理是通过使用Class类的相关方法来获取并操作类的信息。
在Java中，每个类都有一个对应的Class对象，这个Class对象提供了获取类的相关信息的方法。
我们可以通过Class类提供的方法来获取类的构造方法、成员变量、方法等信息，并可以在运行时动态地创建对象、调用方法等操作。
二、反射机制的应用场景1. 动态加载类利用反射机制，我们可以在运行时动态地加载类。
这种灵活性使得我们可以根据配置文件或用户输入等条件来决定具体加载哪个类，从而实现程序的灵活可配置性。
2. 创建对象通过反射机制，我们可以在运行时动态地创建对象。
通常情况下，我们需要通过类的构造方法来创建对象，而反射机制可以使我们在运行时根据需要选择合适的构造方法来创建对象。
3. 调用方法反射机制还可以用于在运行时动态地调用方法。
通过调用Class对象的getMethod()方法，我们可以获取指定方法的实例，并可以利用invoke()方法来调用该方法。
这种动态调用方法的能力可以使得我们根据运行时的条件来选择调用不同的方法，从而实现更加灵活的程序逻辑。
4. 访问成员变量利用反射机制，我们可以在运行时动态地访问类的成员变量。
通过调用Class对象的getField()方法，我们可以获取指定成员变量的实例，并可以利用get()和set()方法来读取和修改成员变量的值。
这样，我们就可以在运行时根据需要来访问和修改对象的成员变量。
5. 动态代理反射机制还可以用于实现动态代理。
动态代理是一种设计模式，它允许我们在不修改原始类的情况下增强该类的功能。
Java反射机制是指在运行时获取类的信息，包括属性和方法，以及动态地创建对象、调用方法等。
以下是一些常见的Java 反射应用场景实例：1. 动态代理：反射机制可以用于实现动态代理，即在运行时动态地生成代理对象，从而实现对目标对象的方法拦截和增强。
这在需要对对象的行为进行控制和修改的场景中非常有用，例如，实现安全控制、日志记录、性能统计等功能。
2. 框架开发：在框架开发中，反射机制可以帮助我们实现参数绑定、依赖注入等功能。
例如，Spring框架中使用反射实现Bean的创建和依赖注入。
3. 注解处理：Java反射可以用于处理注解（Annotation），注解是一种元数据，可以在运行时读取和处理。
例如，在Spring框架中，使用反射来处理@Controller、@Service、@Repository等注解，从而实现自动扫描和初始化组件。
4. 序列化和反序列化：反射机制可以用于实现对象的序列化和反序列化，即在运行时将对象转换为字节数组，以及在反序列化时将字节数组转换为对象。
这在需要对对象进行持久化存储的场景中非常有用，例如，将对象序列化为JSON或XML格式存储。
5. 运行时动态加载类：反射机制可以用于在运行时动态地加载类，从而实现对类的热加载。
这在需要对程序进行动态修改的场景中非常有用，例如，在运行时动态地加载和卸载类库。
6. 自定义注解实现日志管理：通过反射机制可以读取和处理自定义注解，从而实现日志记录。
例如，在开发中，可以使用自定义注解来标记需要记录日志的方法或属性，然后在运行时通过反射读取并处理这些注解，实现日志记录功能。
7. 动态创建对象：反射机制可以用于在运行时动态地创建对象，从而实现对对象的创建和初始化过程的控制。
例如，在开发中，可以使用反射来根据配置文件中的信息动态地创建对象，从而实现对象的依赖注入和自动配置。
8. 实现跨平台插件系统：反射机制可以用于实现跨平台的插件系统，即在运行时动态地加载和调用插件。
Java学习之反射机制及应⽤场景介绍前⾔：最近公司正在进⾏业务组件化进程，其中的路由实现⽤到了Java的反射机制，既然⽤到了就想着好好学习总结⼀下，其实⽆论是之前的EventBus 2.x版本还是Retrofit、早期的View注解框架都或多或少的⽤到Java的反射机制。
什么是Java反射机制？JAVA反射机制是在运⾏状态中，对于任意⼀个类，都能够知道这个类的所有属性和⽅法；对于任意⼀个对象，都能够调⽤它的任意⼀个⽅法；这种动态获取的以及动态调⽤对象的⽅法的功能称为Java的反射机制。
反射机制提供了哪些功能？在运⾏时判定任意⼀个对象所属的类在运⾏时构造任意⼀个类的对象；在运⾏时判定任意⼀个类所具有的成员变量和⽅法；在运⾏时调⽤任意⼀个对象的⽅法；⽣成动态代理；Java反射机制类：ng.Class; //类ng.reflect.Constructor;//构造⽅法ng.reflect.Field; //类的成员变量ng.reflect.Method;//类的⽅法ng.reflect.Modifier;//访问权限Java反射机制实现：1.）class对象的获取//第⼀种⽅式通过对象getClass⽅法Person person = new Person();Class<?> class1 = person.getClass();//第⼆种⽅式通过类的class属性class1 = Person.class;try {//第三种⽅式通过Class类的静态⽅法——forName()来实现class1 = Class.forName("com.whoislcj.reflectdemo.Person");} catch (ClassNotFoundException e) {e.printStackTrace();}2.）获取class对象的摘要信息boolean isPrimitive = class1.isPrimitive();//判断是否是基础类型boolean isArray = class1.isArray();//判断是否是集合类boolean isAnnotation = class1.isAnnotation();//判断是否是注解类boolean isInterface = class1.isInterface();//判断是否是接⼝类boolean isEnum = class1.isEnum();//判断是否是枚举类boolean isAnonymousClass = class1.isAnonymousClass();//判断是否是匿名内部类boolean isAnnotationPresent = class1.isAnnotationPresent(Deprecated.class);//判断是否被某个注解类修饰String className = class1.getName();//获取class名字包含包名路径Package aPackage = class1.getPackage();//获取class的包信息String simpleName = class1.getSimpleName();//获取class类名int modifiers = class1.getModifiers();//获取class访问权限Class<?>[] declaredClasses = class1.getDeclaredClasses();//内部类Class<?> declaringClass = class1.getDeclaringClass();//外部类3.）获取class对象的属性、⽅法、构造函数等Field[] allFields = class1.getDeclaredFields();//获取class对象的所有属性Field[] publicFields = class1.getFields();//获取class对象的public属性try {Field ageField = class1.getDeclaredField("age");//获取class指定属性Field desField = class1.getField("des");//获取class指定的public属性} catch (NoSuchFieldException e) {e.printStackTrace();}Method[] methods = class1.getDeclaredMethods();//获取class对象的所有声明⽅法Method[] allMethods = class1.getMethods();//获取class对象的所有⽅法包括⽗类的⽅法Class parentClass = class1.getSuperclass();//获取class对象的⽗类Class<?>[] interfaceClasses = class1.getInterfaces();//获取class对象的所有接⼝Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//获取class对象的所有声明构造函数Constructor<?>[] publicConstructors = class1.getConstructors();//获取class对象public构造函数try {Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{String.class});//获取指定声明构造函数 Constructor publicConstructor = class1.getConstructor(new Class[]{});//获取指定声明的public构造函数} catch (NoSuchMethodException e) {e.printStackTrace();}Annotation[] annotations = class1.getAnnotations();//获取class对象的所有注解Annotation annotation = class1.getAnnotation(Deprecated.class);//获取class对象指定注解Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 TypeType[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接⼝的type集合4.）class对象动态⽣成//第⼀种⽅式 Class对象调⽤newInstance()⽅法⽣成Object obj = class1.newInstance();//第⼆种⽅式对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()⽅法⽣成Constructor<?> constructor = class1.getDeclaredConstructor(new Class[]{String.class});//获取指定声明构造函数obj = constructor.newInstance(new Object[]{"lcj"});5.）动态调⽤函数try {// ⽣成新的对象：⽤newInstance()⽅法Object obj = class1.newInstance();//判断该对象是否是Person的⼦类boolean isInstanceOf = obj instanceof Person;//⾸先需要获得与该⽅法对应的Method对象Method method = class1.getDeclaredMethod("setAge", new Class[]{int.class});//调⽤指定的函数并传递参数method.invoke(obj, 28);method = class1.getDeclaredMethod("getAge");Object result = method.invoke(obj, new Class[]{});} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (NoSuchMethodException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}6.)通过反射机制获取泛型类型例如下⾯这种结构//People类public class People<T> {}//Person类继承People类public class Person<T> extends People<String> implements PersonInterface<Integer> {}//PersonInterface接⼝public interface PersonInterface<T> {}获取泛型类型Person<String> person = new Person<>();//第⼀种⽅式通过对象getClass⽅法Class<?> class1 = person.getClass();Type genericSuperclass = class1.getGenericSuperclass();//获取class对象的直接超类的 TypeType[] interfaceTypes = class1.getGenericInterfaces();//获取class对象的所有接⼝的Type集合getComponentType(genericSuperclass);getComponentType(interfaceTypes[0]);getComponentType具体实现private Class<?> getComponentType(Type type) {Class<?> componentType = null;if (type instanceof ParameterizedType) {//getActualTypeArguments()返回表⽰此类型实际类型参数的 Type 对象的数组。
JAVA中的反射机制一，先看一下反射的概念：主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
反射是java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。
但是反射使用不当会成本很高！看概念很晕的，继续往下看。
二，反射机制的作用：1，反编译：.class-->.java2,通过反射机制访问java对象的属性，方法，构造方法等；这样好像更容易理解一些，下边我们具体看怎么实现这些功能。
三，在这里先看一下sun为我们提供了那些反射机制中的类：ng.Class;ng.reflect.Constructor; ng.reflect.Field;ng.reflect.Method;ng.reflect.Modifier;很多反射中的方法，属性等操作我们可以从这四个类中查询。
还是哪句话要学着不断的查询API，那才是我们最好的老师。
四，具体功能实现：1，反射机制获取类有三种方法，我们来获取Employee类型[java]view plain copy print?1.//第一种方式：2.Class c1 = Class.forName("Employee");3.//第二种方式：4.//java中每个类型都有class 属性.5.Class c2 = Employee.class;6.7.//第三种方式：8.//java语言中任何一个java对象都有getClass 方法9.Employee e = new Employee();10.Class c3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 2，创建对象：获取类以后我们来创建它的对象，利用newInstance：1.Class c =Class.forName("Employee");2.3.//创建此Class 对象所表示的类的一个新实例4.Objecto = c.newInstance(); //调用了Employee的无参数构造方法. 3,获取属性：分为所有的属性和指定的属性：a，先看获取所有的属性的写法：1.//获取整个类2. Class c = Class.forName("ng.Integer");3.//获取所有的属性?4. Field[] fs = c.getDeclaredFields();5.6.//定义可变长的字符串，用来存储属性7. StringBuffer sb = new StringBuffer();8.//通过追加的方法，将每个属性拼接到此字符串中9.//最外边的public定义10. sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");11.//里边的每一个属性12.for(Field field:fs){13. sb.append("\t");//空格14. sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等15. sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字16. sb.append(field.getName()+";\n");//属性的名字+回车17. }18.19. sb.append("}");20.21. System.out.println(sb);b，获取特定的属性，对比着传统的方法来学习：1.public static void main(String[] args) throws Exception{2.3.//以前的方式：4./*5. User u = new User();6. u.age = 12; //set7. System.out.println(u.age); //get8. */9.10.//获取类11. Class c = Class.forName("User");12.//获取id属性13. Field idF = c.getDeclaredField("id");14.//实例化这个类赋给o15. Object o = c.newInstance();16.//打破封装17. idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。
这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。
它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。
最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。
反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。
在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。
也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。
所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。
可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。
一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。
所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。
开放性和原因连接是反射系统的两大基本要素。
Java中，反射是一种强大的工具。
它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。
反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。
这使反射成为构建灵活的应用的主要工具。
但需注意的是：如果使用不当，反射的成本很高。
二、Java中的类反射：Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。
Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。
例如，Pascal、C 或者C++ 中就没有办法在程序中获得函数定义相关的信息。
1．检测类：1.1 reflection的工作机制考虑下面这个简单的例子，让我们看看reflection 是如何工作的。
import ng.reflect.*;public class DumpMethods {public static void main(String args[]) {try {Class c = Class.forName(args[0]);Method m[] = c.getDeclaredMethods();for (int i = 0; i < m.length; i++)System.out.println(m[i].toString());} catch (Throwable e) {System.err.println(e);}}}按如下语句执行：java DumpMethods java.util.Stack它的结果输出为：public ng.Object java.util.Stack.push(ng.Object)public synchronized ng.Object java.util.Stack.pop()public synchronized ng.Object java.util.Stack.peek()public boolean java.util.Stack.empty()public synchronized int java.util.Stack.search(ng.Object)这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。
这个程序使用Class.forName 载入指定的类，然后调用getDeclaredMethods 来获取这个类中定义了的方法列表。
ng.reflect.Methods 是用来描述某个类中单个方法的一个类。
1.2 Java类反射中的主要方法对于以下三类组件中的任何一类来说-- 构造函数、字段和方法-- ng.Class 提供四种独立的反射调用，以不同的方式来获得信息。
调用都遵循一种标准格式。
以下是用于查找构造函数的一组反射调用：l Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，l Constructor[] getConstructors() -- 获得类的所有公共构造函数l Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)l Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：l Field getField(String name) -- 获得命名的公共字段l Field[] getFields() -- 获得类的所有公共字段l Field getDeclaredField(String name) -- 获得类声明的命名的字段l Field[] getDeclaredFields() -- 获得类声明的所有字段用于获得方法信息函数：l Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法l Method[] getMethods() -- 获得类的所有公共方法l Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法l Method[] getDeclaredMethods() -- 获得类声明的所有方法1.3开始使用Reflection：用于reflection 的类，如Method，可以在ng.relfect 包中找到。
使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的ng.Class 对象。
在运行中的Java 程序中，用ng.Class 类来描述类和接口等。
下面就是获得一个Class 对象的方法之一：Class c = Class.forName("ng.String");这条语句得到一个String 类的类对象。
还有另一种方法，如下面的语句：Class c = int.class;或者Class c = Integer.TYPE;它们可获得基本类型的类信息。
其中后一种方法中访问的是基本类型的封装类(如Integer) 中预先定义好的TYPE 字段。
第二步是调用诸如getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
一旦取得这个信息，就可以进行第三步了——使用reflection API 来操作这些信息，如下面这段代码：Class c = Class.forName("ng.String");Method m[] = c.getDeclaredMethods();System.out.println(m[0].toString());它将以文本方式打印出String 中定义的第一个方法的原型。
2．处理对象：如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:a.创建一个Class对象b.通过getField 创建一个Field对象c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).例如：import ng.reflect.*;import java.awt.*;class SampleGet {public static void main(String[] args) {Rectangle r = new Rectangle(100, 325);printHeight(r);}static void printHeight(Rectangle r) {Field heightField;Integer heightValue;Class c = r.getClass();try {heightField = c.getField("height");heightValue = (Integer) heightField.get(r);System.out.println("Height: " + heightValue.toString());} catch (NoSuchFieldException e) {System.out.println(e);} catch (SecurityException e) {System.out.println(e);} catch (IllegalAccessException e) {System.out.println(e);}}}三、安全性和反射：在处理反射时安全性是一个较复杂的问题。
反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。
但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。
由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。
基本模式是对反射实施与应用于源代码接入相同的限制：n 从任意位置到类公共组件的接入n 类自身外部无任何到私有组件的接入n 受保护和打包（缺省接入）组件的有限接入不过至少有些时候，围绕这些限制还有一种简单的方法。
我们可以在我们所写的类中，扩展一个普通的基本类ng.reflect.AccessibleObject 类。
这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。
唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。
如果未许可，安全性管理器抛出一个例外。
下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：public class ReflectSecurity {public static void main(String[] args) {try {TwoString ts = new TwoString("a", "b");Field field = clas.getDeclaredField("m_s1");// field.setAccessible(true);System.out.println("Retrieved value is " +field.get(inst));} catch (Exception ex) {ex.printStackTrace(System.out);}}}如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。
