第十六章总结：反射和注解

1：访问构造方法 

反射：

1.class类

2.获取构造方法

3.获取成员属性

4.获取成员方法

注解

1.内置注解

2.反射注解

3

创建Class对象的三种方式

1.使用getClass（）方法

object str = new object（）；

class c = str.getClass（）

1. Demo1 d1 = new Demo1();

2. Class c1 = d1.getClass();

2.使用.class属性

class c = object.class

Class c2 = Demo1.class;

3.使用class类的forname方法

class c = class.forname（"全路径"）

2. Class c3 = Class.forName("com.mr.Demo1");

创建class，包会自动创建 

2. package com.mr;

3. public class Demo1 {

4. String s;

5. int i, i2, i3;

6. private Demo1() {

7. }

8. protected Demo1(String s, int i) {

9. this.s = s;

10. this.i = i;

11. }

12. public Demo1(String... strings) throws NumberFormatException {

13. if (0 < strings.length)

14. i = Integer.valueOf(strings[0]);

15. if (1 < strings.length)

16. i2 = Integer.valueOf(strings[1]);

17. if (2 < strings.length)

18. i3 = Integer.valueOf(strings[2]);

19. }

21. public void print() {

22. // TODO Auto-generated method stub

23. System.out.println("s=" + s);

24. System.out.println("i=" + i);

25. System.out.println("i2=" + i2);

26. System.out.println("i3=" + i3);

27. }

28. }

29. //例题16.1

1. import java.lang.reflect.Constructor;

2. import com.mr.Demo1;

4. public class ConstructorDemo1 {

5. public static void main(String[] args) {

6. Demo1 d1 = new Demo1("10", "20", "30");

7. Class<? extends Demo1> demoClass = d1.getClass();

8. // 获得所有构造方法

9. Constructor[] declaredConstructors = demoClass.getDeclaredConstructors();

10. for (int i = 0; i < declaredConstructors.length; i++) { // 遍历构造方法

11. Constructor<?> constructor = declaredConstructors[i];

12. System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());

13. System.out.println("该构造方法的入口参数类型依次为：");

14. Class[] parameterTypes = constructor.getParameterTypes(); // 获取所有参数类型

15. for (int j = 0; j < parameterTypes.length; j++) {

16. System.out.println(" " + parameterTypes[j]);

17. }

18. System.out.println("该构造方法可能抛出的异常类型为：");

19. // 获得所有可能抛出的异常信息类型

20. Class[] exceptionTypes = constructor.getExceptionTypes();

21. for (int j = 0; j < exceptionTypes.length; j++) {

22. System.out.println(" " + exceptionTypes[j]);

23. }

24. Demo1 d2 = null;

25. try { // 如果该成员变量的访问权限为private，则抛出异常，即不允许访问

26. if (i == 2) // 通过执行默认没有参数的构造方法创建对象

27. d2 = (Demo1) constructor.newInstance();

28. else if (i == 1)

29. // 通过执行具有两个参数的构造方法创建对象

30. d2 = (Demo1) constructor.newInstance("7", 5);

31. else { // 通过执行具有可变数量参数的构造方法创建对象

32. Object[] parameters = new Object[] { new String[] { "100", "200", "300" } };

33. d2 = (Demo1) constructor.newInstance(parameters);

34. }

35. } catch (Exception e) {

36. System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");

37. constructor.setAccessible(true); // 设置为允许访问

38. }

39. if (d2 != null) {

40. d2.print();

41. System.out.println();

42. }

43. }

45. }

46. }

47. //例题16.

2：访问成员变量

1. package com.mr;

3. public class Demo2 {

4. int i;

5. public float f;

6. protected boolean b;

7. private String s;

8. }

9. //例题16.2

1. import java.lang.reflect.Field;

2. import com.mr.Demo2;

4. public class FieldDemo {

5. public static void main(String[] args) {

6. Demo2 example = new Demo2();

7. Class exampleC = example.getClass();

8. // 获得所有成员变量

9. Field[] declaredFields = exampleC.getDeclaredFields();

10. for (int i = 0; i < declaredFields.length; i++) { // 遍历成员变量

11. Field field = declaredFields[i];

12. System.out.println("名称为：" + field.getName()); // 获得成员变量名称

13. Class fieldType = field.getType(); // 获得成员变量类型

14. System.out.println("类型为：" + fieldType);

15. boolean isTurn = true;

16. while (isTurn) {

17. // 如果该成员变量的访问权限为private，则抛出异常，即不允许访问

18. try {

19. isTurn = false;

20. // 获得成员变量值

21. System.out.println("修改前的值为：" + field.get(example));

22. if (fieldType.equals(int.class)) { // 判断成员变量的类型是否为int型

23. System.out.println("利用方法setInt()修改成员变量的值");

24. field.setInt(example, 168); // 为int型成员变量赋值

25. } else if (fieldType.equals(float.class)) { // 判断成员变量的类型是否为float型

26. System.out.println("利用方法setFloat()修改成员变量的值");

27. field.setFloat(example, 99.9F); // 为float型成员变量赋值

28. // 判断成员变量的类型是否为boolean型

29. } else if (fieldType.equals(boolean.class)) {

30. System.out.println("利用方法setBoolean()修改成员变量的值");

31. field.setBoolean(example, true); // 为boolean型成员变量赋值

32. } else {

33. System.out.println("利用方法set()修改成员变量的值");

34. field.set(example, "MWQ"); // 可以为各种类型的成员变量赋值

35. }

36. // 获得成员变量值

37. System.out.println("修改后的值为：" + field.get(example));

38. } catch (Exception e) {

39. System.out.println("在设置成员变量值时抛出异常，" + "下面执行setAccessible()方法！");

40. field.setAccessible(true); // 设置为允许访问

41. isTurn = true;

42. }

43. }

44. System.out.println();

45. }

46. }

47. }

48. //例题16.2

3:访问成员方法

3. package com.mr;

5. public class Demo3 {

6. static void staticMethod() {

7. System.out.println("执行staticMethod()方法");

8. }

10. public int publicMethod(int i) {

11. System.out.println("执行publicMethod()方法");

12. return i * 100;

13. }

15. protected int protectedMethod(String s, int i) throws NumberFormatException {

16. System.out.println("执行protectedMethod()方法");

17. return Integer.valueOf(s) + i;

18. }

20. private String privateMethod(String... strings) {

21. System.out.println("执行privateMethod()方法");

22. StringBuffer stringBuffer = new StringBuffer();

23. for (int i = 0; i < strings.length; i++) {

24. stringBuffer.append(strings[i]);

25. }

26. return stringBuffer.toString();

27. }

28. }

29. //例题16.3

2. import java.lang.reflect.*;

4. import com.mr.Demo3;

6. public class MethondDemo {

7. public static void main(String[] args) {

8. Demo3 demo = new Demo3();

9. Class demoClass = demo.getClass();

10. // 获得所有方法

11. Method[] declaredMethods = demoClass.getDeclaredMethods();

12. for (int i = 0; i < declaredMethods.length; i++) {

13. Method method = declaredMethods[i]; // 遍历方法

14. System.out.println("名称为：" + method.getName()); // 获得方法名称

15. System.out.println("是否允许带有可变数量的参数：" + method.isVarArgs());

16. System.out.println("入口参数类型依次为：");

17. // 获得所有参数类型

18. Class[] parameterTypes = method.getParameterTypes();

19. for (int j = 0; j < parameterTypes.length; j++) {

20. System.out.println(" " + parameterTypes[j]);

21. }

22. // 获得方法返回值类型

23. System.out.println("返回值类型为：" + method.getReturnType());

24. System.out.println("可能抛出的异常类型有：");

25. // 获得方法可能抛出的所有异常类型

26. Class[] exceptionTypes = method.getExceptionTypes();

27. for (int j = 0; j < exceptionTypes.length; j++) {

28. System.out.println(" " + exceptionTypes[j]);

29. }

30. boolean isTurn = true;

31. while (isTurn) {

32. try {// 如果该方法的访问权限为private，则抛出异常，即不允许访问

33. isTurn = false;

34. if ("staticMethod".equals(method.getName()))

35. method.invoke(demo); // 执行没有入口参数的方法

36. else if ("publicMethod".equals(method.getName()))

37. System.out.println("返回值为：" + method.invoke(demo, 168)); // 执行方法

38. else if ("protectedMethod".equals(method.getName()))

39. System.out.println("返回值为：" + method.invoke(demo, "7", 5)); // 执行方法

40. else if ("privateMethod".equals(method.getName())) {

41. Object[] parameters = new Object[] { new String[] { "M", "W", "Q" } }; // 定义二维数组

42. System.out.println("返回值为：" + method.invoke(demo, parameters));

43. }

44. } catch (Exception e) {

45. System.out.println("在执行方法时抛出异常，" + "下面执行setAccessible()方法！");

46. method.setAccessible(true); // 设置为允许访问

47. isTurn = true;

48. }

49. }

50. System.out.println();

51. }

52. }

53. }

54. //例题16.3