黑马程序员_基础加强之反射

 -------android培训、java培训、期待与您交流！ ----------

概论：

反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。

反射的好处：大大的增强了程序的扩展性。

类AA：

class AA{
 public AA(String name){
  System.out.println(name);
 }
 public AA(int id,String name){
  System.out.println(id+" "+name);
 }
 public int id;
 public String name;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}

实现类：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class MyReflection {
 
 public static void main(String[] args) {
  
  //定义需要反射的class文件的路径
  String classPath = "com.cao.reflection.AA";
  try {
   //通过下面的方法对class文件里的东西进行封装，可以在此基础上操作获得里面的类结构
   Class<?> class1 = Class.forName(classPath);
   //获取所有的构造器
   Constructor[] constructors = class1.getConstructors();
   System.out.println("指定类的构造器的个数是："+constructors.length);
   /*
    * 打印构造器的定义形式（参见下面定义的AA类里的两个构造器）
    * 结果是：public com.cao.reflection.AA(java.lang.String args0)
     public com.cao.reflection.AA(int args0,java.lang.String args1)
    */
   for(Constructor<?> constructor:constructors){
    //获得对应构造函数的参数类型
    Class<?>[] ptype = constructor.getParameterTypes();
    //获得构造函数的修饰符（modifier），getModfiers（）返回的是int类型，需要通过Modifier类转换为相应的修饰符
    System.out.print(Modifier.toString(constructor.getModifiers())+" ");
    //获得构造函数的名字
    System.out.print(constructor.getName()+"(");
    for (int i = 0; i < ptype.length; i++) {
     //依次打印该构造函数所传递的参数
     System.out.print(ptype[i].getName()+" args"+i);
     //控制','的输出
     if(i<ptype.length-1){
      System.out.print(",");
     }
    }
    System.out.print(")");
    System.out.println();
   }
   
   //还可以根据打印输出的构造函数结构，调用相应的含参的构造函数
   Object obj = constructors[1].newInstance(1,"bird");
   
   
   Field[] fields =class1.getDeclaredFields();
   for(Field field:fields){
    System.out.println(Modifier.toString(field.getModifiers())+" "+field.getType().getName()+" "+field.getName());
   }
   
   //同样也可以通过class1.getDeclaredMethods()方法获取所有的方法，返回一个Method[]
   
   //获取指定的方法
   Field field = class1.getDeclaredField("name");
   //第一个参数为方法名，第二个是一个可变参数，为变量类型
   Method method =class1.getDeclaredMethod("setName", field.getType());
   
   //调用获得的方法,第一个参数为该class文件的一个实例，第二个参数为该方法需要的参数（可变参数）
   //这句话就相当于obj实例调用了他的一个method对应的方法
   //因为我们不知道通过Class.forName(classPath).newInstance()方法实例中到底有什么方法
   //只有通过这种方法对其里面的方法进行操作，struts框架填充form就是利用反射的这一点实现的
   method.invoke(obj, "cat");
   //调用完里面的对应方法后，我们就可以转型回来看看里面的东西了
   AA aa = (AA) obj;
   System.out.println(aa.getName());
   
   
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (InstantiationException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchFieldException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchMethodException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}