• java反射的使用

     

    数据准备 

    自定义注解

    1. import java.lang.annotation.Retention;
    2. import java.lang.annotation.RetentionPolicy;
    3. import java.lang.annotation.Target;
    4. import static java.lang.annotation.ElementType.*;
    5.  
    6. @Target({TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
    7. @Retention(RetentionPolicy.RUNTIME)
    8.  
    9. public @interface MyAnnotation {
    10.  
    11. 	String value() default "hello";
    12. }

     自定义接口

    1. public interface MyInterface {
    2.  
    3. 	void info();
    4. }

    带泛型的父类

    1. public class Creature<T> implements Serializable {
    2.  
    3. 	private char gender;
    4. 	public double weight;
    5. 	
    6. 	private void breath() {
    7. 		System.out.println("生物呼吸");
    8. 	}
    9. 	
    10. 	private void eat() {
    11. 		System.out.println("生物吃东西");
    12. 	}
    13. }

    子类Person类

    1. import java.util.Comparator;
    2.  
    3. @MyAnnotation(value = "hi")
    4. public class Person extends Creature<String> implements Comparator<String> ,MyInterface{
    5.  
    6. 	private String name;
    7. 	int age;
    8. 	public int id;
    9. 	
    10. 	
    11. 	public Person() {
    12. 		super();
    13. 	}
    14. 	
    15. 	private Person(String name) {
    16. 		this.name=name;
    17. 	}
    18.  
    19. 	@MyAnnotation(value="abc")
    20. 	public Person(String name, int age, int id) {
    21. 		super();
    22. 		this.name = name;
    23. 		this.age = age;
    24. 		this.id = id;
    25. 	}
    26.  
    27. 	@MyAnnotation
    28. 	private String show(String nation) {
    29. 		System.out.println("我的国籍是:"+nation);
    30. 		return nation;
    31. 	}
    32. 	
    33. 	public String display(String interests,int age) 
    34. 			throws NullPointerException,ClassCastException{
    35. 		return interests+age;
    36. 	}
    37. 	
    38. 	@Override
    39. 	public void info() {
    40. 		System.out.println("我是一个人");
    41. 	}
    42.  
    43. 	@Override
    44. 	public int compare(String o1, String o2) {
    45. 		return 0;
    46. 	}
    47.  
    48. 	
    49. 	private static void showDesc() {
    50. 		System.out.println("我是一个可爱的人");
    51. 	}
    52.  
    53. 	@Override
    54. 	public String toString() {
    55. 		return "Person [name=" + name + ", age=" + age + ", id=" + id + "]";
    56. 	}
    57. 	
    58. 	
    59. }

    测试类

    FieldTest：获取当前运行时类的属性结构

    1. import java.lang.reflect.Field;
    2. import java.lang.reflect.Modifier;
    3.  
    4. import org.junit.jupiter.api.Test;
    5.  
    6. import reflect.java2.Person;
    7.  
    8.  
    9.  
    10. /**
    11.  * 获取当前运行时类的属性结构
    12.  * @author CharlieLiang
    13.  *
    14.  */
    15. public class FieldTest {
    16.  
    17. 	@Test
    18. 	public void test() {
    19. 		Class clazz = Person.class;
    20. 		
    21. 		//获取属性结构
    22. 		// getFields():获取当前运行时类及其父类中声明为public访问权限的属性
    23. 		System.out.println("--getFields()--");
    24. 		Field[] fs= clazz.getFields();
    25. 		for(Field f: fs) {
    26. 			System.out.println(f);
    27. 		}
    28. 		
    29. 		System.out.println("---getDeclaredFields()----");
    30. 		//getDeclaredFields():获取当前类的所有属性，不包含父类
    31. 		Field[] fs2 = clazz.getDeclaredFields();
    32. 		for(Field f:fs2) {
    33. 			System.out.println(f);
    34. 		}
    35. 	}
    36. 	
    37. 	// 权限修饰符 数据类型  变量名
    38. 	@Test
    39. 	public void test2() {
    40. 		Class clazz = Person.class;
    41. 		Field[] fs = clazz.getDeclaredFields();
    42. 		
    43. 		for(Field f:fs) {
    44. 			//1. 权限修饰符 0:默认修饰符,modifer是数字，把数字转为修饰符名字
    45. 			int modifiers = f.getModifiers();
    46. 			System.out.print(Modifier.toString(modifiers)+"\t");
    47. 			
    48. 			//2. 数据类型
    49. 			Class type=f.getType();
    50. 			System.out.print(type.getName()+"\t");
    51. 			
    52. 			// 3.变量名
    53. 			String fName=f.getName();
    54. 			System.out.print(fName);
    55. 			System.out.println();
    56. 		}
    57. 		
    58. 		
    59. 	}
    60. }

    运行结果：

    test

    test2

     MehtodTest：获取运行时类的方法

    1. import java.lang.annotation.Annotation;
    2. import java.lang.reflect.Method;
    3. import java.lang.reflect.Modifier;
    4.  
    5. import org.junit.jupiter.api.Test;
    6.  
    7. import reflect.java2.Person;
    8.  
    9.  
    10. /**
    11.  * 获取运行时类的方法的使用
    12.  * @author CharlieLiang
    13.  *
    14.  */
    15. public class MethodTest {
    16.  
    17. 	@Test
    18. 	public  void test() {
    19. 		Class clazz=Person.class;
    20. 		//getMethods():获取当前类及其所有父类中声明为public权限的方法
    21. 		System.out.println("-----------getMethods()-----------------");
    22. 		Method[] mds = clazz.getMethods();
    23. 		for(Method md:mds) {
    24. 			System.out.println(md);
    25. 		}
    26. 		System.out.println("-----------getDeclaredMethods()------------");
    27. 		// 获取当前类的声明的方法(不包含父类)
    28. 		Method[] dmds = clazz.getDeclaredMethods();
    29. 		for(Method md:dmds) {
    30. 			System.out.println(md);
    31. 		}
    32. 	}
    33. 	
    34. 	/**
    35. 	 * @XXX
    36. 	 * 权限修饰符	返回值类型	方法名(参数类型1	形参名1,....) throws XxxException()
    37. 	 */
    38. 	@Test
    39. 	public void test2() {
    40. 		Class clazz=Person.class;
    41. 		Method[] dmds = clazz.getDeclaredMethods();
    42. 		for(Method md:dmds) {
    43. 			//获取注解
    44. 			
    45. 			Annotation[] annos = md.getAnnotations();
    46. 			
    47. 			for(Annotation a: annos) {
    48. 				
    49. 				System.out.println(a);
    50. 			}
    51. 			
    52. 			//2 .权限修饰符
    53. 			System.out.print(Modifier.toString(md.getModifiers())+"\t");
    54. 			
    55. 			//3. 返回值类型 getReturnType()-->class java.lang.String
    56. 			// getReturnType().getName()-->java.lang.String
    57. 			System.out.print(md.getReturnType().getName()+"\t");
    58. 			System.out.print(md.getName());
    59. 			
    60. 			System.out.print("(");
    61. 			//5. 形参列表
    62. 			Class<?>[] parameterTypes = md.getParameterTypes();
    63. 			if(!((parameterTypes==null)&&(parameterTypes.length==0))) {
    64. 				for(int i=0;i<parameterTypes.length;i++) {
    65. 					if(i==parameterTypes.length-1) {
    66. 						System.out.print(parameterTypes[i].getName()+" arg_"+i);
    67. 						break;
    68. 					}
    69. 					System.out.print(parameterTypes[i].getName()+" arg_"+i+",");
    70. 				}
    71. 			}
    72. 			System.out.print(")");
    73. 			
    74. 			
    75. 			//6.异常
    76. 			Class<?>[] exceptionTypes = md.getExceptionTypes();
    77. 			if(exceptionTypes.length>0) {
    78. 				System.out.print("throws ");
    79. 				for(int i=0;i<exceptionTypes.length;i++) {
    80. 					if(i== exceptionTypes.length-1) {
    81. 						System.out.print(exceptionTypes[i].getName());
    82. 						break;
    83. 					}
    84. 					System.out.print(exceptionTypes[i].getName()+",");
    85. 				}
    86. 				
    87. 			}
    88. 			System.out.println();
    89. 		}
    90. 	}
    91. }

    OtherTest：其他测试

    1. import java.lang.annotation.Annotation;
    2. import java.lang.reflect.Constructor;
    3. import java.lang.reflect.ParameterizedType;
    4. import java.lang.reflect.Type;
    5.  
    6. import org.junit.jupiter.api.Test;
    7.  
    8. import reflect.java2.Person;
    9.  
    10. /**
    11.  * 
    12.  * @author CharlieLiang
    13.  *
    14.  */
    15. public class OtherTest {
    16.  
    17. 	/**
    18. 	 * 获取构造器结构
    19. 	 */
    20. 	@Test
    21. 	public void test() {
    22. 		Class clazz=Person.class;
    23. 		
    24. 		Constructor[] constructors = clazz.getConstructors();
    25. 		System.out.println("----------getConstructors()--------------");
    26. 		// getConstructors():获取当前运行时类声明为public的构造器
    27. 		for(Constructor c: constructors) {
    28. 			System.out.println(c);
    29. 		}
    30. 		// getDeclaredConstructors():获取当前运行时类中声明的所有构造器
    31. 		System.out.println("---------getDeclaredConstructors()-----------");
    32. 		Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    33. 		for(Constructor c:declaredConstructors) {
    34. 			System.out.println(c);
    35. 		}
    36. 	}
    37. 	
    38. 	/**
    39. 	 * 获取运行时类的父类
    40. 	 */
    41. 	@Test
    42. 	public void test2() {
    43. 		Class clazz=Person.class;
    44. 		Class superclass = clazz.getSuperclass();
    45. 		System.out.println(superclass);
    46. 	}
    47. 	
    48. 	
    49. 	/**
    50. 	 * 获取运行时类的带泛型的父类
    51. 	 */
    52. 	@Test
    53. 	public void test3() {
    54. 		Class clazz=Person.class;
    55. 		Type genericSuperclass = clazz.getGenericSuperclass();
    56. 		System.out.println(genericSuperclass);
    57. 	}
    58. 	
    59. 	/**
    60. 	 * 获取运行时类的父类的泛型
    61. 	 */
    62. 	@Test
    63. 	public void test4() {
    64. 		Class clazz=Person.class;
    65. 		Type genericSuperclass = clazz.getGenericSuperclass();
    66. 		ParameterizedType paramType=(ParameterizedType) genericSuperclass;
    67. 		//获取泛型类型
    68. 		Type[] actualTypeArguments = paramType.getActualTypeArguments();
    69. 		System.out.println(actualTypeArguments[0]);
    70. 		System.out.println(actualTypeArguments[0].getTypeName());
    71. 	}
    72. 	
    73. 	/**
    74. 	 * 获取运行时类的接口
    75. 	 */
    76. 	@Test
    77. 	public void test5() {
    78. 		Class clazz = Person.class;
    79. 		Class[] interfaces = clazz.getInterfaces();
    80. 		for(Class c: interfaces) {
    81. 			System.out.println(c);
    82. 		}
    83. 		
    84. 		System.out.println();
    85. 		Class[] interfaces2 = clazz.getSuperclass().getInterfaces();
    86. 		
    87. 		for(Class c: interfaces2) {
    88. 			System.out.println(c);
    89. 		}
    90. 	}
    91. 	
    92. 	/**
    93. 	 * 获取运行时类所在的包
    94. 	 */
    95. 	@Test
    96. 	public void test6() {
    97. 		Class clazz = Person.class;
    98. 		Package pack = clazz.getPackage();
    99. 		System.out.println(pack);
    100. 	}
    101. 	
    102.  
    103. 	/**
    104. 	 * 获取运行时类所在的注解
    105. 	 */
    106. 	@Test
    107. 	public void test7() {
    108. 		Class clazz = Person.class;
    109. 		Annotation[] as = clazz.getAnnotations();
    110. 		for(Annotation aaa:as) {
    111. 			System.out.println(aaa);
    112. 		}
    113. 	}
    114. }

    ReflectionTest：调用运行时类指定的结构： 属性，方法，构造器 

    1. import java.lang.reflect.Constructor;
    2. import java.lang.reflect.Field;
    3. import java.lang.reflect.Method;
    4.  
    5. import org.junit.jupiter.api.Test;
    6.  
    7. import reflect.java2.Person;
    8.  
    9.  
    10.  
    11. /**
    12.  * 调用运行时类指定的 结构： 属性，方法，构造器
    13.  * @author CharlieLiang
    14.  *
    15.  */
    16. public class ReflectionTest {
    17.  
    18. 	@Test
    19. 	public void testField() throws Exception {
    20. 		Class clazz=Person.class;
    21. 		
    22. 		//创建运行时类对象
    23. 		Person p= (Person) clazz.newInstance();
    24. 		
    25. 		//获取指定的属性getField():获取public变量
    26. 		Field id= clazz.getField("id");
    27. 		
    28. 		id.set(p, 1001);
    29. 		
    30. 		//获取当前属性的值
    31. 		int pid = (int) id.get(p);
    32. 		System.out.println(pid);
    33. 	}
    34. 	
    35. 	/**
    36. 	 * 如何操作运行时类中的指定属性 -- 需要掌握
    37. 	 * @throws Exception
    38. 	 */
    39. 	@Test
    40. 	public void testField2() throws Exception {
    41. 		Class clazz=Person.class;
    42. 		
    43. 		//创建运行时类对象
    44. 		Person p= (Person) clazz.newInstance();
    45. 		
    46. 		//获取指定的属性getField():获取public变量
    47. 		//私有变量name
    48. 		Field name= clazz.getDeclaredField("name");
    49. 		//保证当前属性是可访问的
    50. 		name.setAccessible(true);
    51. 		//获取、设置指定对象的此属性值
    52. 		//set(对象，参数)
    53. 		name.set(p, "Jerry");
    54. 		System.out.println(name.get(p));
    55. 	}
    56. 	
    57. 	
    58. 	/**
    59. 	 * 如何操作运行时类中的指定方法 -- 需要掌握
    60. 	 * 
    61. 	 */
    62. 	@Test
    63. 	public void testField3() throws Exception {
    64. 		Class clazz=Person.class;
    65. 		
    66. 		//创建运行时类对象
    67. 		Person p= (Person) clazz.newInstance();
    68. 		//getDeclaredMethod(方法名，参数列表)
    69. 		Method show=clazz.getDeclaredMethod("show", String.class);
    70. 		show.setAccessible(true);
    71. 		
    72. 		//invoke(对象，参数列表），invoke有方法返回值
    73. 		Object returnVal = show.invoke(p, "CHN");
    74. 		System.out.println("返回值"+returnVal);
    75. 		
    76. 		System.out.println("----如何调用静态方法-------");
    77. 		
    78. 		//private static void showDesc()
    79. 		Method showDesc=clazz.getDeclaredMethod("showDesc");
    80. 		showDesc.setAccessible(true);
    81. 		
    82. 		//showDesc：无参数，void型的invoke返回null
    83. 		Object returnval2 = showDesc.invoke(Person.class);
    84. 		System.out.println("返回值："+returnval2);
    85. 	}
    86. 	
    87. 	
    88. 	/**
    89. 	 * 如何操作运行时类中的指定构造器
    90. 	 * @throws Exception 
    91. 	 * @throws  
    92. 	 * 
    93. 	 */
    94. 	@Test
    95. 	public void testField4() throws Exception {
    96. 		Class clazz=Person.class;
    97. 		
    98. 		//getDeclaredConstructor():指明参数列表
    99. 		Constructor cons =clazz.getDeclaredConstructor(String.class);
    100. 		
    101. 		cons.setAccessible(true);
    102. 		//用构造器创建运行时类的对象
    103. 		Person person = (Person) cons.newInstance("Jack");
    104. 		
    105. 		System.out.println(person);
    106. 	}
    107. 	
    108. }

  • 相关阅读:
    Gin学习记录4——Controller和中间件
    GAMES101 作业0 环境配置 超详细小白教程
    携职教育：《会计类考证》报考要求与攻略
    城市旅游景点信息交流平台的设计与实现 毕业设计-附源码290915
    commet与websocket
    Angular自定义异步表单验证
    【Python游戏】Python基于pygame实现的人机大战的斗兽棋小游戏 | 附源码
    C++：适配器
    创建ES索引
    Tips--lib静态库调用外部函数
  • 原文地址：https://blog.csdn.net/m0_46306264/article/details/125565662