Java反射机制

今天学习了一下Java的反射机制，发现关键字new是造成耦合度高的重要原因，感觉对反射没有什么总结，看了一篇博客园的文章，觉得总结的不错，就转载过来学习一下了！

下面是主要的内容：

1. /** 

2.  * 反射机制获取类有三种方法 

3.  */  

4. @Test  

5. public void testGetClass() throws ClassNotFoundException {  

6.     Class clazz = null;  

7.   

8.     //1 直接通过类名.Class的方式得到  

9.     clazz = Person.class;  

10.       System.out.println("通过类名: " + clazz);  

11.     

12.       //2 通过对象的getClass()方法获取,这个使用的少（一般是传的是Object，不知道是什么类型的时候才用）  

13.       Object obj = new Person();  

14.       clazz = obj.getClass();  

15.       System.out.println("通过getClass(): " + clazz);  

16.     

17.       //3 通过全类名获取，用的比较多，但可能抛出ClassNotFoundException异常  

18.       clazz = Class.forName("com.java.reflection.Person");  

19.       System.out.println("通过全类名获取: " + clazz);  

20.   }  

21.     /** 

22.      * Field: 封装了字段的信息 

23.      */  

24.     @Test  

25.     public void testField() throws  

26.             ClassNotFoundException, NoSuchFieldException, IllegalAccessException {  

27.       

28.         Class clazz = Class.forName("com.java.reflection.Person");  

29.       

30.         //1、获取字段  

31.         //1.1 获取Field的数组,私有字段也能获取  

32.         Field[] fields = clazz.getDeclaredFields();  

33.         for (Field field: fields) {  

34.             System.out.print(field.getName() + ", ");  

35.         }  

36.       

37.         //1.2 获取指定名字的Field（如果是私有的，见下面的4)  

38.         Field field = clazz.getDeclaredField("name");  

39.         System.out.println("\n获取指定Field名=: " + field.getName());  

40.       

41.         Person person = new Person("ABC", 12);  

42.         //2、获取指定对象的Field的值  

43.         Object val = field.get(person);  

44.         System.out.println("获取指定对象字段'name'的Field的值=： " + val);  

45.       

46.         //3、设置指定对象的Field的值  

47.         field.set(person, "changwen2");  

48.         System.out.println("设置指定对象字段'name'的Field的值=: " + person.name);  

49.       

50.         //4、若该字段是私有的，需要调用setAccessible(true)方法  

51.         Field field2 = clazz.getDeclaredField("age");  

52.         field2.setAccessible(true);  

53.         System.out.println("获取指定私有字段名=: " + field2.getName());  

54.     }  

55.     /** 

56.      * 一个实例： 

57.      * 反射获取一个继承Person2的Student类 

58.      * 设置字段"age"=20(该字段可能为私有，可能在其父类中） 

59.      */  

60.     @Test  

61.     public void testClassField() throws ClassNotFoundException, IllegalAccessException, InstantiationException {  

62.         String className = "com.java.reflection.Student";  

63.         String fieldName = "age";  //可能为私有，可能在其父类中  

64.         Object val = 20;  

65.       

66.         //创建className 对应类的对象，并为其fieldName赋值为val  

67.         Class clazz = Class.forName(className);  

68.         Field field = null;  

69.         for (Class clazz2 = clazz; clazz2 != Object.class; clazz2 = clazz2.getSuperclass()){  

70.             try {  

71.                 field = clazz2.getDeclaredField(fieldName);  

72.             } catch (Exception e) {  

73.       

74.             }  

75.         }  

76.       

77.         Object obj = clazz.newInstance();  

78.         assert field != null;  

79.         field.setAccessible(true);  

80.         field.set(obj, val);  

81.       

82.         Student stu = (Student) obj;  

83.         System.out.println("age = " + stu.getAge());  

84.     }  

85.     /** 

86.      * 构造器：开发用的比较少 

87.      */  

88.     @Test  

89.     public void testConstructor() throws ClassNotFoundException, NoSuchMethodException,  

90.             IllegalAccessException, InvocationTargetException, InstantiationException {  

91.         String className = "com.java.reflection.Person";  

92.         Class<Person> clazz = (Class<Person>) Class.forName(className);  

93.       

94.         //1.获取Constructor对象  

95.         Constructor<Person>[] constructors =  

96.                 (Constructor<Person>[]) Class.forName(className).getConstructors();  

97.       

98.         for (Constructor<Person> constructor: constructors) {  

99.             System.out.println(constructor);  

100.       }  

101.     

102.       Constructor<Person> constructor = clazz.getConstructor(String.class, Integer.class);  

103.       System.out.println("指定的-->" + constructor);  

104.     

105.       //2.调用构造器的newInstance()方法创建对象  

106.       Object obj= constructor.newInstance("changwen", 11);  

107.   }  

以上是java反射机制的主要方法

想知道更完整的内容，就去看原文即可：

原文出处：https://www.cnblogs.com/bojuetech/p/5896551.html