java反射

public class Test_Reflection {

 public static void main(String[] args) throws ClassNotFoundException {
  //TestReflection tf = new TestReflection();
  //有些时候，我们并不一定能够直接去new对象
  //然后获取对象里面的属性
  //所以只能通过对象的名字，或者对象本身，反过来去查找对象的所有的属性
  //反过来找，其实就是通过反射找到每个对象对应的class对象
 

 

 
  //获得class对象有三种方式
  //1.编译器已经知道类的名字
  Class c1 = TestReflection.class;
  //2.已经获得了类的对象
  TestReflection tf = new TestReflection();
  Class c2 = tf.getClass();
  //3.通过运行期获取class
  Class c3 = Class.forName("test.TestReflection");

  //获取包名
  String packageName = c1.getPackage().getName();
  System.out.println(packageName);

 

  //获取的类的权限修饰符
  int mod = c1.getModifiers();
  String modifier = Modifier.toString(mod);
  
  //获取类的全名
  String className = c1.getName();
  
  System.out.println(modifier + " " + className);
  
  //获取类的父类
  Class superClass = c1.getSuperclass();
  System.out.println(Modifier.toString(superClass.getModifiers())
    + " class " + superClass.getName());
  
  //获取父接口
  Class [] is = c1.getInterfaces();
  
  for(Class t : is){
   System.out.println(Modifier.toString(t.getModifiers())
     + " interface " + t.getName());
  }

 
  //获得成员变量
  Field [] fs = c1.getDeclaredFields();
  
  for(Field f : fs){
   //获得每个字段访问修饰符
   String mods = Modifier.toString(f.getModifiers());
   //获得每个字段的类型
   Class type = f.getType();
   //获得类型名
   String typeName = type.getName();
   //获得字段名
   String fieldName = f.getName();
   
   //如果是数组，需要判断
   if(type.isArray()){
    typeName = type.getComponentType().getName() + "[]";
   }
   
   System.out.println(mods + " " + typeName + " " + fieldName);
   
  }
  

 
  //获得构造方法
  Constructor [] cs = c1.getDeclaredConstructors();
  for(Constructor c : cs){
   //获得构造方法的名字
   String cName = c.getName();
   //获得构造方法的修饰符
   String cMod = Modifier.toString(c.getModifiers());
   //获得构造方法中的参数
   Class [] paramTypes = c.getParameterTypes();
   
   System.out.print(cMod + " " + cName + "(");
   
   for(int i=0; i<paramTypes.length; i++){
    if( i > 0 ){
     System.out.print(",");
    }
    //如果是数组需要特殊处理
    if(paramTypes[i].isArray()){
     System.out.print(paramTypes[i].getComponentType().getName() + "[]");
    }else{
     System.out.print(paramTypes[i].getName());
    }
   }
   
   System.out.println(")");
  }

 

  
  System.out.println("----------------成员方法----------------");
  //获得成员方法
  Method [] methods = c1.getDeclaredMethods();
  //遍历所有的成员方法
  for(Method m : methods){
   //获取访问修饰符
   String mmod = Modifier.toString(m.getModifiers());
   
   //获取方法的返回值类型
   Class rType = m.getReturnType();
   String returnType = "";
   if(rType.isArray()){
    returnType = rType.getComponentType().getName() + "[]";
   }else{
    returnType = rType.getName();
   }
   
   //获取方法名
   String mname = m.getName();
   //获取参数
   Class [] paramTypes = m.getParameterTypes();
   
   System.out.print(mmod + " " + mname + "(");
   
   for(int i=0; i<paramTypes.length; i++){
    if( i > 0 ){
     System.out.print(",");
    }
    //如果是数组需要特殊处理
    if(paramTypes[i].isArray()){
     System.out.print(paramTypes[i].getComponentType().getName() + "[]");
    }else{
     System.out.print(paramTypes[i].getName());
    }
   }
   
   System.out.println(")");
  }

 

  System.out.println("--------------通过反射调用方法----------------");
  
  //我们还可以通过反射直接去调用方法
  //可以通过Method类中的invoke方法实现动态的调用
  //public Object invoke(Obejct,Object...args)
  //第一个参数表示对象
  //第二个参数开始是表示方法需要传入的参数
  
  //之前其实已经获得了c1,c2,c3这几个Class对象,其实我们可以直接将Class对象再转化为实例化对象
  try {
   //这里实例化的是不带参的构造方法
   TestReflection tf1 = (TestReflection)c1.newInstance();
   tf1.name = "张三";
   tf1.password = "1111";
   System.out.println(tf1.name + "  " + tf1.password);
   
   //通过Class实例化带参的构造方法
   //通过构造方法实例化，其实需要先实例化构造方法对象
   Constructor cons = c3.getConstructor(new Class[]{String.class,String.class,int[].class});
   //实例化构造方法对象
   Object obj = cons.newInstance(new Object[]{"李四","abcd",new int[]{99,100,88}});
   //将构造方法对象转换为具体实例化对象
   TestReflection tf2 = (TestReflection)obj;
   System.out.println(tf2.name + " " + tf2.password + " " + tf2.score[1]);
   
   
   //通过反射调用方法
   Method m1 = c3.getDeclaredMethod("setName", String.class);
   m1.invoke(tf2, "王五");
   System.out.println(tf2.name);
   
   //通过反射调用带数组的方法
   Method m2 = c3.getDeclaredMethod("setScore", int[].class);
   int [] nums = {1,2,4};
   m2.invoke(tf2, nums);
   System.out.println(tf2.score[1]);
   
   //通过反射调用private修饰的方法
   Method m3 = c3.getDeclaredMethod("setPassword", String.class);
   m3.setAccessible(true);
   m3.invoke(tf2, "9999");
   System.out.println(tf2.password);
   
  } catch (InstantiationException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (NoSuchMethodException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (SecurityException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IllegalArgumentException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 
 }

}