JAVA反射

一、什么是动态性语言

一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。
尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods1。这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

二、什么是反射

反射说白了就是通过一个字符串去得到相应的实例，来操作该实例。
反射在实际的应用中，其实非常广。然后这些都封装在了框架中。现在的软件设计理念中都提倡低耦合的设计方式。比如我们在action中不提倡Service s=new Serivce();因为这样就以Serivce有了相当的高的耦合度。不利于软件的扩展和复用。所以我们通常用spring来进行依赖注入结果这个问题。而spring如何给action注入实例呢，其实就是通过解析xml。反射实例来注入。只不过这一切都封装起来了。

 

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

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

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：

Class类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method类：代表类的方法。
Constructor 类：代表类的构造方法。
Array类：提供了动态创建数组，以及访问数组的元素的静态方法。

三、反射使用步骤

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

  (1)通过Class.forName("类的全限定名")来获得类对象
     Class c1 = Class.forName("Java.lang.String");
     Class c2 = Class.forName("day9.Sturnt");

  (2)通过类名获得类对象 Class c3 = Student.class;

  (3)通过类的对象获得类对象  Class c4 = s.getClass();  //s是Student的引用.


第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

第三步 取得这信息后，就可以使用 reflection API 来操作这些信息

四、反射例子

1、得到某个对象的属性

2、使用反射创建新实例

 

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
//一个学生类
 class Student {
      String name;
      public Student(){
              System.out.println("create Student");
      }
      public Student(String name){
              super();
              System.out.println("create Student"+name);
              this.name=name;
      }
      public void study(String course,String teacher){
              System.out.println("Student"+name+"study"+course+"by"+teacher);
      }
}

public class test {
      public static void main(String[] args) throws Exception{

          Class c= Class.forName(args[0]);       //args[0]:Student 
          Class[] ps={String.class};             //参数表

          //1得到构造方法对象
          Constructor con=c.getConstructor(ps);
          Object[] os={args[1]};                    //args[1]:zhuxy         

          //2.通过构造方法对象去构造对象
          Object o=con.newInstance(os);
          Class[] ps2={String.class,String.class};  //方法参数表
          String methodName=args[2];                //要掉的方法名args[2]:study

          //3.得到方法对象
          Method m=c.getMethod(methodName, ps2);
          Object[] os2={args[3],args[4]};           //args[3]:java  args[4]:tangliang

          //4调用方法
          m.invoke(o, os2);
      }
 }

 

3、用反射机制调用对象的方法

 

import java.lang.reflect.Method;
public class test {    
	public int add(int param1, int param2) {        
		return param1 + param2;    
		}    
	public String echo(String msg) {        
		return "echo: " + msg;    
		}    
	public static void main(String[] args) throws Exception {        
		Class<?> classType = test.class;        
		Object invokeTester = classType.newInstance();               
		//获取InvokeTester类的add()方法       
		
		Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});        
		//调用invokeTester对象上的add()方法        
		Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});        
		System.out.println((Integer) result);        
		//获取InvokeTester类的echo()方法       
		Method echoMethod = classType.getMethod("echo", new Class[]{String.class});        
		//调用invokeTester对象的echo()方法        
		result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});        
		System.out.println((String) result);    
	}
}

 

 

4、通过反射更改字段值

import java.lang.reflect.Field;

public class test {    
	public double x;    
	public Double y;    
	public static void main(String args[]) 
	throws NoSuchFieldException, IllegalAccessException {        
		Class c = test.class;        
		Field xf = c.getField("x");        
		Field yf = c.getField("y");        
		test obj = new test();        
		System.out.println("变更前x=" + xf.get(obj));        	   
		xf.set(obj, 1.1);  //变更成员x值          
		System.out.println("变更后x=" + xf.get(obj));        
		System.out.println("变更前y=" + yf.get(obj));       		    
		yf.set(obj, 2.1);  //变更成员y值         
		System.out.println("变更后y=" + yf.get(obj));    
	}
}

 

四、反射的缺点

 直到现在，我们仅仅讨论了反射如何好以及它如何使生活更轻松。不幸的是，任何事情都有代价。尽管反射功能非常强大并且提供了很大的灵活性，但是我们 不应该使用反射编写任何内容。如果可能的话，在某些情况下您可能希望避免使用反射。因为反射会引入以下缺点：性能开销、安全限制以及暴露隐藏的成员。

有时，通过访问修改程序保存逻辑。下面的代码片段就是一个鲜明的例子：

public class Student {
	private String name;

	public Student(String name) {
		this.name = name;
	}
}

  

当初始化对象后，只能通过构造函数更改学生的姓名。使用反射，您可以将学生的姓名设置任何 String，甚至在初始化对象之后也可以。正如您所见到的一样，这样会打乱业务逻辑并且可能会使程序行为不可预测。

与大多数其他编译器一样，Java 编译器尝试尽可能多的优化代码。对于反射这是不可能的，因为反射是在运行时解析类型，而编译器是在编译时工作。此外，必须在稍后的阶段即运行时解析类型。

结束语

反射可用于在不同对象中实现相同的逻辑（如搜索）， 而不需要为每个新类型都创建新代码。这样也有利于对逻辑进行集中管理。遗憾的是，反射也存在缺点，它有时会增加代码的复杂性。性能是对反射的另一个负面影响，因为无法在此类代码上执行优化。