为了方便记忆 java 的反射机制,在这里仔细的总结了一下。主要是怕以后忘记了,这样也方便回忆。因为最近利用空余时间深入的了解 spring 和 Mybatis 框架,
像 spring 中核心模块 IOC 底层实现的原理就是反射机制,mybatis 也是利用 java 的反射机制来获取和设置对象的值的。由此看来 java 反射机制还是很强大的,其实也蛮有趣的。
Java 语言允许通过程序化的方式间接对 Class 的对象实例操作,Class 文件由类装载器装载后,在 JVM 中将形成一份描述 Class 结构的元信息对象,通过该元信息对象可以获知 Class 的结构信息:构造函数、属性和方法等。Java 允许用户借由这个 Class 相关的元信息对象间接调用 Class 对象的功能.
JAVA 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。注意是在运行状态中。
"程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言"。Java 不是动态语言。但是 Java 有着一个非常突出的动态相关机制:Reflection,用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes。换句话说,Java 程序可以加载一个运行时才得知名称的 class,获悉其完整构造(但不包括 methods 定义),并生成其对象实体、或对其 fields 设值、或唤起其 methods。
看了定义有点稍微的明白了,
反射之中包含了一个 "反" 的概念,要解释反射就必须先从 "正" 开始解释,一般而言,要产生实例化对象一定要有类。如下:
- import java.util.Date; //先导入类
- public class ReflectionDemo {
- public static void main(String[] args) {
- Date date = new Date(); //再产对象
- System.out.println(date);
- }
- }
而所谓的 "反",是通过对象找到类。在 Object 类里面提供有一个方法:
- public final Class < !--?-->getClass()
通过 getClass 方法我们可以获取到这个对象对应的反射类
注:反射之中的所有泛型都定义为?,返回值都是 Object。
- import java.util.Date;//先导入类
- public class ReflectionDemo {
- public static void main(String[] args) {
- Date date = new Date();//再产对象
- Class<?> c =date.getClass();
- System.out.println(c);
- }
- }
- 输出为:class java.util.Date
我们发现,调用 getClass() 后,得到了类的完整名称。也就找到了对象的出处
java.lang.Class 是一个类,它和一般类一样继承自 Objec。这个类是反射操作的源头,即所有的反射都要从此类开始进行,如何获取一个对象对应的反射类 Class,在 Java 中我们有三种方法可以获取一个对象的反射类:
即上述例子,此处略过。
- //import java.util.Date;//先导入类
- public class ReflectionDemo {
- public static void main(String[] args) throws Exception {
- Class<?> c = Class.forName("java.util.Date");
- System.out.println(c);
- }
- }
- 输出:class java.util.Date
注意:此时,无需使用 import 语句导入一个明确的类,而类名称是采用字符串的形式进行描述的。
- import java.util.Date; //先导入类
- public class ReflectionDemo {
- public static void main(String[] args) {
- Class < ?>c = Date.class;
- System.out.println(c);
- }
- }
一般情况下,对象的实例化操作需要依靠构造方法和关键字 new 完成。可是有了 Class 类对象之后,可以利用反射来实现对象的实例化。
- Class<?> c = Class.forName("com.putao.Person");
- Person p = (Person)c.newInstance();//相当于使用new调用无参构造实例化对象
- p.setName("张三");
- System.out.println(p.getName());
- 输出:张三
注意:newInstance 只能调用默认的无参构造方法, 若类中不提供无参构造方法,只能明确的调用有参构造方法。(一般创建类的时候尽量保留有无参构造)
Class 类中有取得构造的方法
- public Constructor<t> getConstructor(Class<!--?-->... parameterTypes)
- Class<?> c = Class.forName("com.putao.Person");
- // Person p = (Person)c.newInstance();
- // p.setName("张三");
- Constructor<?> con = c.getConstructor(String.class,int.class);
- Object obj = con.newInstance("李四",22);//实例化对象
- Person p2 = (Person) obj;
- System.out.println(p2.toString());
- 输出:Person [name=李四, age=22]
程序的开发尽量降低耦合。而降低耦合的最好做法是使用接口,但是就算使用了接口也逃不出关键字 new,所以实际上 new 是造成耦合的关键元凶。反射机制实例化对象的时候实际上只需要 "包. 类" 就可以
- package com.putao;
- interface Fruit{
- public void eat();
- }
- class Apple implements Fruit{
- @Override
- public void eat(){
- System.out.println("eat apple");
- }
- }
- class Grape implements Fruit{
- @Override
- public void eat(){
- System.out.println("eat grape");
- }
- }
- class Orange implements Fruit{
- @Override
- public void eat(){
- System.out.println("eat orange");
- }
- }
- class Factory{
- public static Fruit getInstance(String className){
- /*if("apple".equals(className)){
- return new Apple();
- }else if("orange".equals(className)){
- return new Orange();
- }
- return null;*/
- Fruit f = null;
- try {
- f = (Fruit)Class.forName(className).newInstance();
- } catch (Exception e) {
- e.printStackTrace();
- }
- return f;
- }
- }
- public class FactoryDemo{
- public static void main(String[] args){
- /*Fruit f = Factory.getInstance("apple");
- f.eat();
- Fruit f1 = Factory.getInstance("orange");
- f1.eat();*/
- Fruit f1= Factory.getInstance("com.putao.Apple");
- f1.eat();
- Fruit f2 = Factory.getInstance("com.putao.Orange");
- f2.eat();
- Fruit f3 = Factory.getInstance("com.putao.Grape");
- f3.eat();
- }
- }
- 输出:eat apple
- eat orange
- eat grape
即使后来增加了接口的子类,工厂类照样可以完成对象的实例化操作,这样的工厂类,可以应对于所有的变化。这就完成了解耦合的目的,而且扩展性非常强。
Class 类中有
- 取得一个类中的全部方法:
- public Method[] getMethods() throws SecurityException
- 取得指定方法:
- public Method getMethod(String name, Class<?>... parameterTypes) throws
- NoSuchMethodException, SecurityException
- 取得全部成员:
- public Field[] getDeclaredFields() throws SecurityException
- 取得指定成员:
- public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException
例:获取方法
- Class < ?>c = Class.forName("com.putao.Person");
- Object obj = c.newInstance();
- Method setMet = c.getMethod("setName", String.class);
- setMet.invoke(obj, "张三"); //等价于调用person类的setName("张三")
- Method getMet = c.getMethod("getName");
- System.out.println(getMet.invoke(obj)); //等价于调用person类的getName()方法
- 输出:张三
例:获取属性
- Class<?> c = Class.forName("com.putao.Person");
- Object obj =c.newInstance();
- Field titleField = c.getDeclaredField("name");
- titleField.setAccessible(true);//解除封装
- titleField.set(obj, "张三");//相当于Person类对象.name = "张三"
- System.out.println(titleField.get(obj));//相当于Person类对象。name
来源: http://www.cnblogs.com/favour/p/7282889.html