学习java应该如何理解反射？

小子吃饭去 猿类/技术渣/热爱和妹子有关的话题

163 人赞同

【此反射来自于李兴华的java se 实战经典，非做广告，网上有视频教程资源和笔记word素材，如果有需要可以留言】

网上百度出来的word文档，侵删

魔乐MLDN 13天搞定JAVA 魔乐课堂实战系列.doc_免费高速下载

——————————————————第二次更新——————————————————

更新内容：对齐样式

反射之中包含了一个“反”的概念，所以要想解释反射就必须先从“正”开始解释，一般而言，当用户使用一个类的时候，应该先知道这个类，而后通过这个类产生实例化对象，但是“反”指的是通过对象找到类。

packagecn.mldn.demo;classPerson {}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Person per = newPerson() ; // 正着操作System.out.println(per.getClass().getName()); // 反着来}}

以上的代码使用了一个getClass()方法，而后就可以得到对象所在的“包.类”名称，这就属于“反”了，但是在这个“反”的操作之中有一个getClass()就作为发起一切反射操作的开端。

Person的父类是Object类，而上面所使用getClass()方法就是Object类之中所定义的方法。

·取得Class对象：public final Class<?> getClass()，反射之中的所有泛型都定义为?，返回值都是Object。

而这个getClass()方法返回的对象是Class类的对象，所以这个Class就是所有反射操作的源头。但是在讲解其真正使用之前还有一个需要先解释的问题，既然Class是所有反射操作的源头，那么这个类肯定是最为重要的，而如果要想取得这个类的实例化对象，Java中定义了三种方式：

方式一：通过Object类的getClass()方法取得，基本不用：

packagecn.mldn.demo;classPerson {}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Person per = newPerson() ; // 正着操作Class<?> cls = per.getClass() ; // 取得Class对象System.out.println(cls.getName()); // 反着来}}

方式二：使用“类.class”取得，在日后学习Hibernate开发的时候使用

packagecn.mldn.demo;classPerson {}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Person.class; // 取得Class对象System.out.println(cls.getName()); // 反着来}}

方式三：使用Class类内部定义的一个static方法，主要使用

·取得Class类对象：public static Class<?> forName(String className) throws ClassNotFoundException；

packagecn.mldn.demo;classPerson {}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象System.out.println(cls.getName()); // 反着来}}

那么现在一个新的问题又来了，取得了Class类的对象有什么用处呢？对于对象的实例化操作之前一直依靠构造方法和关键字new完成，可是有了Class类对象之后，现在又提供了另外一种对象的实例化方法：

·通过反射实例化对象：public T newInstance() throws InstantiationException, IllegalAccessException；

范例：通过反射实例化对象

packagecn.mldn.demo;classPerson {@OverridepublicString toString() {return"Person Class Instance .";}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Object obj = cls.newInstance() ; // 实例化对象，和使用关键字new一样Person per = (Person) obj ; // 向下转型System.out.println(per);}}

那么现在可以发现，对于对象的实例化操作，除了使用关键字new之外又多了一个反射机制操作，而且这个操作要比之前使用的new复杂一些，可是有什么用？

对于程序的开发模式之前一直强调：尽量减少耦合，而减少耦合的最好做法是使用接口，但是就算使用了接口也逃不出关键字new，所以实际上new是造成耦合的关键元凶。

范例：回顾一下之前所编写的工厂设计模式

packagecn.mldn.demo;interfaceFruit {publicvoideat() ;}classApple implementsFruit {publicvoideat() {System.out.println("吃苹果。");};}classFactory {publicstaticFruit getInstance(String className) {if("apple".equals(className)){returnnewApple() ;}returnnull;}}publicclassFactoryDemo {publicstaticvoidmain(String[] args) {Fruit f = Factory.getInstance("apple") ;f.eat() ;}}

以上为之前所编写最简单的工厂设计模式，但是在这个工厂设计模式之中有一个最大的问题：如果现在接口的子类增加了，那么工厂类肯定需要修改，这是它所面临的最大问题，而这个最大问题造成的关键性的病因是new，那么如果说现在不使用关键字new了，变为了反射机制呢？

反射机制实例化对象的时候实际上只需要“包.类”就可以，于是根据此操作，修改工厂设计模式。

packagecn.mldn.demo;interfaceFruit {publicvoideat() ;}classApple implementsFruit {publicvoideat() {System.out.println("吃苹果。");};}classOrange implementsFruit {publicvoideat() {System.out.println("吃橘子。");};}classFactory {publicstaticFruit getInstance(String className) {Fruit f = null;try{f = (Fruit) Class.forName(className).newInstance() ;} catch(Exception e) {e.printStackTrace();}returnf ;}}publicclassFactoryDemo {publicstaticvoidmain(String[] args) {Fruit f = Factory.getInstance("cn.mldn.demo.Orange") ;f.eat() ;}}

发现，这个时候即使增加了接口的子类，工厂类照样可以完成对象的实例化操作，这个才是真正的工厂类，可以应对于所有的变化。如果单独从开发角度而言，与开发者关系不大，但是对于日后学习的一些框架技术这个就是它实现的命脉，在日后的程序开发上，如果发现操作的过程之中需要传递了一个完整的“包.类”名称的时候几乎都是反射机制作用。

3.12.2 、反射的深入应用

以上只是利用了Class类作为了反射实例化对象的基本应用，但是对于一个实例化对象而言，它需要调用类之中的构造方法、普通方法、属性，而这些操作都可以通过反射机制完成。

3.12.2 .1、调用构造

使用反射机制也可以取得类之中的构造方法，这个方法在Class类之中已经明确定义了：

以下两个方法

取得一个类的全部构造：

public Constructor<?>[] getConstructors() throws SecurityException

取得一个类的指定参数构造：

public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

现在发现以上的两个方法返回的都是java.lang.reflect.Constructor类的对象。

范例：取得一个类之中的全部构造

packagecn.mldn.demo;importjava.lang.reflect.Constructor;classPerson { // CTRL + KpublicPerson() {}publicPerson(String name) {}publicPerson(String name,intage) {}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Constructor<?> cons [] = cls.getConstructors() ; // 取得全部构造for(intx = 0; x < cons.length; x++) {System.out.println(cons[x]);}}}

验证：在之前强调的一个简单Java类必须存在一个无参构造方法

范例：观察没有无参构造的情况

packagecn.mldn.demo;classPerson { // CTRL + KprivateString name;privateintage;publicPerson(String name,intage) {this.name= name ;this.age= age ;}@OverridepublicString toString() {return"Person [name="+ name+ ", age="+ age+ "]";}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Object obj = cls.newInstance(); // 实例化对象System.out.println(obj);}}

此时程序运行的时候出现了错误提示“java.lang.InstantiationException”，因为以上的方式使用反射实例化对象时需要的是类之中要提供无参构造方法，但是现在既然没有了无参构造方法，那么就必须明确的找到一个构造方法，而后利用Constructor类之中的新方法实例化对象：

·实例化对象：public T newInstance(Object... initargs) throws InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException

packagecn.mldn.demo;importjava.lang.reflect.Constructor;classPerson { // CTRL + KprivateString name;privateintage;publicPerson(String name,intage) {this.name= name ;this.age= age ;}@OverridepublicString toString() {return"Person [name="+ name+ ", age="+ age+ "]";}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象// 取得指定参数类型的构造方法Constructor<?> cons = cls.getConstructor(String.class,int.class) ;Object obj = cons.newInstance("张三", 20); // 为构造方法传递参数System.out.println(obj);}}

很明显，调用无参构造方法实例化对象要比调用有参构造的更加简单、方便，所以在日后的所有开发之中，凡是有简单Java类出现的地方，都一定要提供无参构造。

3.12.2 .2、调用普通方法

当取得了一个类实例化对象之后，下面最需要调用的肯定是类之中的方法，所以可以继续使用Class类取得一个类中所定义的方法定义：

·取得全部方法：public Method[] getMethods() throws SecurityException；

·取得指定方法：public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

发现以上的方法返回的都是java.lang.reflect.Method类的对象。

范例：取得一个类之中所定义的全部方法

packagecn.mldn.demo;importjava.lang.reflect.Method;classPerson {privateString name;publicvoidsetName(String name) {this.name= name;}publicString getName() {returnname;}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Method met [] = cls.getMethods() ; // 取得全部方法for(intx = 0; x < met.length; x++) {System.out.println(met[x]);}}}

但是取得了Method类对象最大的作用不再于方法的列出（方法的列出都在开发工具上使用了），但是对于取得了Method类对象之后还有一个最大的功能，就是可以利用反射调用类中的方法：

·调用方法：public Object invoke(Object obj, Object... args) throws IllegalAccessException,IllegalArgumentException, InvocationTargetException

之前调用类中方法的时候使用的都是“对象.方法”，但是现在有了反射之后，可以直接利用Object类调用指定子类的操作方法。（同时解释一下，为什么setter、getter方法的命名要求如此严格）。

范例：利用反射调用Person类之中的setName()、getName()方法

packagecn.mldn.demo;importjava.lang.reflect.Method;classPerson {privateString name;publicvoidsetName(String name) {this.name= name;}publicString getName() {returnname;}}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Object obj = cls.newInstance(); // 实例化对象，没有向Person转型String attribute = "name"; // 要调用类之中的属性Method setMet = cls.getMethod("set"+ initcap(attribute), String.class);// setName()Method getMet = cls.getMethod("get"+ initcap(attribute));// getName()setMet.invoke(obj, "张三") ; // 等价于：Person对象.setName("张三")System.out.println(getMet.invoke(obj));// 等价于：Person对象.getName()}publicstaticString initcap(String str) {returnstr.substring(0,1).toUpperCase().concat(str.substring(1)) ;}}

在日后的所有框架技术开发之中，简单Java类都是如此应用的，所以必须按照标准进行。

3.12.2 .3、调用成员

类之中最后一个组成部分就是成员（Field，也可以称为属性），如果要通过反射取得类的成员可以使用方法如下：

·取得本类的全部成员：public Field[] getDeclaredFields() throws SecurityException；

·取得指定的成员：public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException；

这两个方法的返回值类型是java.lang.reflect.Field类的对象，下面首先观察如何取得一个类之中的全部属性。

范例：取得一个类之中的全部属性

packagecn.mldn.demo;importjava.lang.reflect.Field;classPerson {privateString name;}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person") ; // 取得Class对象Field field [] = cls.getDeclaredFields() ; // 取得全部属性for(intx = 0; x < field.length; x++) {System.out.println(field[x]);}}}

但是找到Field实际上就找到了一个很有意思的操作，在Field类之中提供了两个方法：

·设置属性内容（类似于：对象.属性= 内容）：public void set(Object obj, Object value)

throws IllegalArgumentException, IllegalAccessException；

·取得属性内容（类似于：对象.属性）：public Object get(Object obj)

throws IllegalArgumentException, IllegalAccessException

可是从类的开发要求而言，一直都强调类之中的属性必须封装，所以现在调用之前要想办法解除封装。

·解除封装：public void setAccessible(boolean flag) throws SecurityException；

范例：利用反射操作类中的属性

packagecn.mldn.demo;importjava.lang.reflect.Field;classPerson {privateString name;}publicclassTestDemo {publicstaticvoidmain(String[] args) throwsException {Class<?> cls = Class.forName("cn.mldn.demo.Person"); // 取得Class对象Object obj = cls.newInstance(); // 对象实例化属性才会分配空间Field nameField = cls.getDeclaredField("name") ; // 找到name属性nameField.setAccessible(true) ; // 解除封装了nameField.set(obj, "张三") ; // Person对象.name = "张三"System.out.println(nameField.get(obj)); // Person对象.name}}

编辑于 2015-12-13 24 条评论 感谢 

分享

 收藏 • 没有帮助 • 举报 • 作者保留权利

郭无心 做好自己

30 人赞同

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。

下面具体介绍一下java的反射机制。

Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method;

其中class代表的时类对 象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组 成部分。

Java反射的作用：

在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。对于任意一个对象，可以调用它的任意一个方法。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

Java 反射机制主要提供了以下功能

在运行时判断任意一个对象所属的类。在运行时构造任意一个类的对象。在运行时判断任意一个类所具有的成员变量和方法。在运行时调用任意一个对象的方法

反射的常用类和函数:Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method；

其中class代表的是类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象，通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类，它是实现反射的基础，它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法，下面我们主要介绍Class类中针对这三个元素的方法:

1、得到构造器的方法

 Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，  Constructor[] getConstructors() -- 获得类的所有公共构造函数  Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)  Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 

2、获得字段信息的方法

Field getField(String name) -- 获得命名的公共字段  Field[] getFields() -- 获得类的所有公共字段  Field getDeclaredField(String name) -- 获得类声明的命名的字段  Field[] getDeclaredFields() -- 获得类声明的所有字段 

3、获得方法信息的方法

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法  Method[] getMethods() -- 获得类的所有公共方法  Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法  Method[] getDeclaredMethods() -- 获得类声明的所有方法 

在程序开发中使用反射并结合属性文件，可以达到程序代码与配置文件相分离的目的

如果我们想要得到对象的信息，一般需要“引入需要的‘包.类’的名称——通过new实例化——取得实例化对象”这样的过程。使用反射就可以变成“实例化对象——getClass()方法——得到完整的‘包.类’名称”这样的过程。

正常方法是通过一个类创建对象，反射方法就是通过一个对象找到一个类的信息。

from: https://www.zhihu.com/question/24304289