Java反射的小故事

Java反射的小故事：

首先定义一个Java类

 package com.xiaoysec.test;

 public class Person {
     private String name;
     private String sex;
     private int id;

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public Person(String name, String sex, int id) {
         this.name = name;
         this.sex = sex;
         this.id = id;
     }
     private void show(){
         System.out.println("name is:"+this.name);
         System.out.println("sex is:"+this.sex);
         System.out.println("id is:"+this.id);
     }
     public static void main(String[] args){
         System.out.println(args[0]);
     }
 }

在类中定义了一些方法，尤其注意的是方法的访问权限，show()方法被定义为了私有方法，以前上课的时候只是说private修饰的方法或属性只能在类的内部进行访问，那么这句话有没有问题呢？

 package com.xiaoysec.test;

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

 import org.junit.Test;

 public class Classtest {
     private String simplename;

     @Test
     public void test() {

         try {
             Class c = Class.forName("com.xiaoysec.test.Person");
             Constructor constructor = c.getConstructor(new Class[] {
                     String.class, String.class, int.class });
             Person p = (Person) constructor.newInstance("xiaoysec", "sex", 19);
             Method m = c.getDeclaredMethod("show", null); // 获取的是private权限的show方法
             m.setAccessible(true); // 强行打开访问权限 使用发射可以访问private方法
                                     // 面试的时候如果被问及private是否可以被访问应该 回答
                                     // 普通的方式只能在类的内部访问 而通过反射可以访问private
             m.invoke(p, null);
             System.out.println(c.getName());
             System.out.println("-------------");
             Field f = c.getDeclaredField("name");
             f.setAccessible(true);
             Class fieldtype = f.getType();
             System.out.println(fieldtype);
             Object o = f.get(p);
             System.out.println(o.getClass()); // 此处返回的是class java.lang.String
             System.out.println(o);
             System.out.println("--------------");
             Method mainmethod = c.getMethod("main", String[].class); // main方法的反射
             // mainmethod.invoke(p, new String[]{"xiaoysec"});//argument type
             // mismatch
             mainmethod.invoke(p, (Object) new String[] { "xiaoysec" });
             // mainmethod.invoke(p,new Object[]{new String[]{"xiaoysec"}});
             // //此方法也是对的
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

 }

请注意setAccessible(true)这点，通过设置，就可以访问private修饰的方法了。

另外在上面的代码中值得一提的是main方法的反射

public static void main(String[] args)

这个大家都不陌生，main方法接收一个String数组，在反射中开始时我写的是mainmethod.invoke(p, new String[]{"xiaoysec"});//argument type mismatch提示参数匹配的错误

解决的方法是这样的

 mainmethod.invoke(p, (Object) new String[] { "xiaoysec" });
  //或者 mainmethod.invoke(p,new Object[]{new String[]{"xiaoysec"}});

为什么呢？

大致可以这样理解 ，当遇到数组类型的参数时 会进行拆分，例如str[0],str[1]...并将拆分后的参数作为方法的实参这样的话就匹配不到合适的参数了当然反射也就失败了

而方法一（Object） 就是故意的转型让方法认为传入的不是数组

方法二 大致的意思就是 经过拆分后获取到第一个String数组作为方法的实参 这样就符合了main方法接收一个String数组作为实参的条件

下面再来看看反射和泛型的基情：

 package com.xiaoysec.reflecttest;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Iterator;

 import org.junit.Test;

 public class Reflecttest {
     @Test
     public void test() {
         ArrayList<String> list = new ArrayList<String>();
         list.add("xiaoysec");
         list.add("B12040423");
         Iterator it = list.iterator();
         while (it.hasNext()) {
             String str = (String) it.next();
             if (str.equals("xiaoysec")) {
                 str = "xiaoy";
                 // list.add("nanjing"); 在iterator作用范围内不能改变集合中的元素
             }
             System.out.println(str);
         }

     }
     /**
      * 下面的測試方法證明了java中的泛型只是针对编译时有效
      * 通过反射可以绕过泛型的限制
     */
     @Test
     public void test2() {
         ArrayList<String> list2 = new ArrayList<String>();
         list2.add("XIAOYSEC");
         list2.add("12040423");
         for(String str:list2){
             System.out.println(str);
         }
         System.out.println("-----------------");
         try {
             Class c = list2.getClass();
             Method m = c.getMethod("add", Object.class);  // public boolean add(E e)
             m.invoke(list2, 12);  //传入的参数是12 int类型而非String类型
             Iterator it = list2.iterator();
             while (it.hasNext()) {
                 System.out.println(it.next());
             }
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

     }

 }

可以看到通过反射可以绕过泛型的限制，也就是说Java泛型是在编译阶段起作用在运行时不会产生限制。