javaweb学习总结四(反射技术)

一：反射的概念

反射就是加载类，然后获取类的属性、方法、构造函数等。

二：加载类到内存(有硬盘字节码文件到内存)

三种加载类的方式：

 @Test
     // 测试加载类
     public void test1() throws Exception {
         // 第一种方式
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         // 第二种方式
         Class clazz2 = new Person().getClass();
         // 第三种方式
         Class clazz3 = Person.class;
     }

三：反射类中的组成部分

1：使用getConstructor()、getMethod()、getField(),可以反射public修饰的成员，

如果需要反射private修饰的成员，需要使用下面的getDeclaredXXX()。

2：反射构造方法

Person定义的构造方法：

 public Person() {
         System.out.println("调用无参构造方法...");
     }

     public Person(String name) {
         System.out.println(name);
     }

     public Person(String name, int age) {
         System.out.println(name + ":" + age);
     }

     private Person(List<String> list) {
         System.out.println(list);
     }

反射构造方法代码：

 @Test
     // 反射无参构造方法
     public void test2() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Constructor c = clazz1.getConstructor(null);
         Person p = (Person) c.newInstance(null);
         System.out.println(p.name);
     }

     @Test
     // 反射参数String的构造方法
     public void test3() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Constructor c = clazz1.getConstructor(String.class);
         Person p = (Person) c.newInstance("Jack");
         System.out.println(p.name);
     }

     @Test
     // 反射参数为String、int的构造方法
     public void test4() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Constructor c = clazz1.getConstructor(String.class, int.class);
         Person p = (Person) c.newInstance("Jack", 27);
         System.out.println(p.name);
     }

     @Test
     // 反射参数为List的构造方法
     public void test5() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Constructor c = clazz1.getDeclaredConstructor(List.class);
         c.setAccessible(true);
         Person p = (Person) c.newInstance(new ArrayList());
         System.out.println(p.name);
     }

其中反射参数为List的构造方法，因为构造方法时private修饰的，所以必须使用getDeclaredConstructor()获取构造方法，

同时需要设置强制方法setAccessible(true);

也可以直接使用反射类获取对象，代码如下：

 @Test
     public void test6() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Person p = (Person) clazz1.newInstance();
         System.out.println(p.name);
     }

2：反射方法

反射方法代码如下：

Person类中定义的普通方法：

 public void abc() {
         System.out.println("abc...");
     }

     public String abc(String name) {
         return name;
     }

     public void abc(String name, int[] i) {
         System.out.println(name + ":" + i);
     }

     public Class[] abc(InputStream in) {
         return new Class[] { String.class };
     }

     public static void abc(int i) {
         System.out.println(i);
     }

反射普通方法：

 @Test
     // public void abc()
     public void test7() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("abc", null);
         m.invoke(p, null);
     }

     @Test
     // public String abc(String name)
     public void test8() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("abc", String.class);
         System.out.println(m.invoke(p, "Tom"));
     }

     @Test
     // public void abc(String name, int[] i)
     public void test9() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("abc", String.class, int[].class);
         m.invoke(p, "Jack", new int[] { 1, 2, 3 });
     }

     @Test
     // public Class[] abc(InputStream in)
     public void test10() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("abc", InputStream.class);
         Class[] cc = (Class[]) m.invoke(p, new FileInputStream("f:/1.txt"));
         System.out.println(cc[0]);
     }

     @Test
     // public static void abc(int i)
     public void test11() throws Exception {
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("abc", int.class);
         m.invoke(null, 27);
     }

Person定义的main方法：

 public static void main(String[] args) {
         System.out.println("调用main...");
     }

反射main方法：

 @Test
     // public static void main(String[] args)
     public void test12() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Method m = clazz1.getMethod("main", String[].class);
         // m.invoke(p, (Object)new String[]{"1","2","3"});
         m.invoke(p, new Object[] { new String[] { "1", "2", "3" } });
     }

这里要注意，由于jdk5兼容了jdk1.4的特性，传入字符串数组时，它会对传入参数进行拆分，

如：new String[]{"1","2","3"}将被拆分成"1"、"2"、"3",所以直接反射会报参数个数异常，

有两种处理方法：

a：在前面加上Object  b：将数组再次放到数组中

3：反射字段

Person类中定义字段：

 public String name = "Tom";
     private int age = 27;
     private static double salary = 8000.0;

反射字段：

 @Test
     // public String name = "Tom";
     public void test13() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Field f = clazz1.getField("name");
         f.set(p, "Jack");
         Object obj = f.get(p);
         Class type = f.getType();
         if (type.equals(String.class)) {
             String value = (String) obj;
             System.out.println(value);
         }
     }

     @Test
     // private int age = 27;
     public void test14() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Field f = clazz1.getDeclaredField("age");
         f.setAccessible(true);
         int i = (Integer) f.get(p);
         System.out.println(i);
     }

     @Test
     // private static double salary = 8000.0;
     public void test15() throws Exception {
         Person p = new Person();
         Class clazz1 = Class.forName("com.hlcui.test.Person");
         Field f = clazz1.getDeclaredField("salary");
         f.setAccessible(true);
         double d = (Double) f.get(p);
         System.out.println(d);
     }

反射的知识就总结到这里！