5、java反射基础

1 package com.aop;
2 
3 abstract public class Creature<T> {
4 
5 }

 1 package com.aop;
 2 
 3 public class Person extends Creature<String>{
 4 
 5     int id;
 6     public String name;
 7     private int age;
 8     
 9     public Person() { }
10     public Person(int age, String name){
11         this.age = age;
12         this.name = name;
13     }
14 
15     public int getId() {
16         return id;
17     }
18 
19     public void setId(int id) {
20         this.id = id;
21     }
22 
23     public String getName() {
24         return name;
25     }
26 
27     public int getAge() {
28         return age;
29     }
30 
31     public void setName(String name) {
32         this.name = name;
33     }
34 
35     public void setAge(int age) {
36         this.age = age;
37     }
38     
39     static public void countAdd(int a, Integer b){
40         System.out.println(a + " + " + b + " = " + (a+b));
41     }
42 
43     public void show() {
44         System.out.println("我是一个人！");
45     }
46 
47     public void display(String nation) {
48         System.out.println("我的国际是：" + nation);
49     }
50 
51     @Override
52     public String toString() {
53         return "Person [name=" + name + ", age=" + age + "]";
54     }
55 
56 }

  1 package com.aop;
  2 
  3 import java.lang.reflect.Constructor;
  4 import java.lang.reflect.Field;
  5 import java.lang.reflect.Method;
  6 import java.lang.reflect.ParameterizedType;
  7 import java.lang.reflect.Type;
  8 
  9 import org.junit.Test;
 10 
 11 public class TestReflection {
 12     
 13     @Test
 14     public void testReflection() throws Exception{
 15         
 16         //1.调用运行时类本身的.class属性
 17         Class<Person> clazz1 = Person.class;
 18         
 19         //2.通过运行时类的对象获取
 20         Person person = new Person();
 21         Class<? extends Person> clazz2 = person.getClass();
 22         
 23         //3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。
 24         String className = "com.aop.Person";
 25         
 26         Class<?> clazz3 = Class.forName(className);
 27         
 28         //4.（了解）通过类的加载器
 29         ClassLoader loader = this.getClass().getClassLoader();
 30         Class<?> clazz4 = loader.loadClass(className);
 31         
 32         System.out.println(clazz1.getName());
 33         System.out.println(clazz2.getName());
 34         System.out.println(clazz3.getName());
 35         System.out.println(clazz4.getName());
 36         
 37         System.out.println(clazz1 == clazz2);
 38         System.out.println(clazz1 == clazz3);
 39         System.out.println(clazz1 == clazz4);
 40     }
 41     
 42     @Test
 43     public void testField() throws Exception{
 44         String className = "com.aop.Person";
 45         Class<?> clazz = Class.forName(className);
 46         
 47         Person person = (Person) clazz.newInstance();
 48         
 49         //getField(...)方法会获取public类型的属性，包括父类的public类型属性都能获取
 50         Field field = clazz.getField("name");
 51         field.set(person, "东东");
 52         System.out.println(person);
 53         
 54         //getDeclaredField(...)获取所有所有类型的属性，但是，不包括父类的属性在内
 55         Field field2 = clazz.getDeclaredField("age");
 56         //如果类中的属性设定为private或者是“默认类型”，则需要设置其可访问属性
 57         field2.setAccessible(true);    
 58         field2.set(person, 100);
 59         System.out.println(person);
 60         
 61     }
 62     
 63     @Test
 64     public void testMethod() throws Exception{
 65         String className = "com.aop.Person";
 66         Class<?> clazz = Class.forName(className);
 67         
 68         Person person = new Person(50, "哈哈");
 69         
 70         //获取并调用无参的show方法
 71         Method method1 = clazz.getMethod("show");
 72         method1.invoke(person);
 73         
 74         //获取并调用有参的display方法
 75         Method method2 = clazz.getMethod("display", String.class);
 76         method2.invoke(person, "中国");
 77         
 78         //调用有返回值的方法
 79         Method method3 = clazz.getMethod("toString");
 80         Object resultVal = method3.invoke(person);
 81         System.out.println(resultVal);
 82         
 83         //调用有参数的静态方法
 84         Method method4 = clazz.getMethod("countAdd", int.class, Integer.class);
 85         method4.invoke(Person.class, 10, 100);
 86     }
 87     
 88     @Test
 89     public void testConstructor() throws Exception{
 90         String className = "com.aop.Person";
 91         Class<?> clazz = Class.forName(className);
 92         
 93         //调用一个有参的构造器
 94         Constructor<?> cons = clazz.getConstructor(int.class, String.class);
 95         Person person = (Person) cons.newInstance(20, "兮兮");
 96         System.out.println(person);
 97     }
 98     
 99     @Test
100     public void testGeneric() throws Exception{
101         String className = "com.aop.Person";
102         Class<?> clazz = Class.forName(className);
103         
104         //1、获取父类，只能得到父类的名称
105         Class<?> superClazz = clazz.getSuperclass();
106         System.out.println(superClazz);
107         
108         //2、获取带泛型的父类
109         Type type = clazz.getGenericSuperclass();
110         System.out.println(type);
111         
112         //3、获取父类的泛型类（重要）
113         ParameterizedType param = (ParameterizedType)type;
114         Type[] argmts = param.getActualTypeArguments();
115         Class<?> claz = (Class<?>)argmts[0];
116         System.out.println(claz);
117     }
118 
119 }