转载请标明出处：http://www.cnblogs.com/zhaoyanjun/p/6074887.html1

本文出自【赵彦军的博客】

反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射机制能做什么

反射机制主要提供了以下功能：

  • 在运行时判断任意一个对象所属的类；
  • 在运行时构造任意一个类的对象；
  • 在运行时判断任意一个类所具有的成员变量和方法；
  • 在运行时调用任意一个对象的方法；
  • 生成动态代理。

反射机制的相关API

**InterFace **接口

  1. package com.app;
  3. public interface InterFace {
  5. 	void read() ;
  7. }

Person 类

  1. package com.app;
  3. public class Person  implements InterFace {
  5. 	private String id ;
  7. 	private String name ;
  9. 	public String age ;
  11. 	//构造函数1
  12. 	public Person( ){
  14. 	}
  16. 	//构造函数2
  17. 	public Person( String id ){
  18. 		this.id = id ;
  19. 	}
  21. 	//构造函数3
  22. 	public Person( String id  , String name ){
  23. 		this.id = id ;
  24. 		this.name = name ;
  25. 	}
  27. 	public String getId() {
  28. 		return id;
  29. 	}
  31. 	public void setId(String id) {
  32. 		this.id = id;
  33. 	}
  35. 	public String getName() {
  36. 		return name;
  37. 	}
  39. 	public void setName(String name) {
  40. 		this.name = name;
  41. 	}
  43. 	public String getAge() {
  44. 		return age;
  45. 	}
  47. 	public void setAge(String age) {
  48. 		this.age = age;
  49. 	}
  51. 	/**
  52. 	 * 静态方法
  53. 	 */
  54. 	public static void update(){
  56. 	}
  58. 	@Override
  59. 	public void read() {
  61. 	}
  63. }
  • 获取类：3种方法
  1. package com.app;
  3. public class T1 {
  5. 	public static void main(String[] args) {
  7. 		//第一种方法：forName
  8. 		try {
  9. 			Class<?> class1 = Class.forName("com.app.Person");
  11. 			System.out.println( class1 );
  12. 		} catch (ClassNotFoundException e) {
  13. 			e.printStackTrace();
  14. 		}
  16. 		//第二张方法：class
  17. 		Class<?> class2 = Person.class;  
  19. 		//第三种方法：getClass
  20. 		Person person = new Person();
  21. 		Class<?> class3 = person.getClass();
  23. 		System.out.println( class2 );
  24. 		System.out.println( class3 );
  25. 	}
  27. }

运行结果：

  1. class com.app.Person
  2. class com.app.Person
  3. class com.app.Person
  • 获取所有的方法：getMethods( )
  1. package com.app;
  3. import java.lang.reflect.Method;
  5. public class T1 {
  7. 	public static void main(String[] args) {
  9. 		try {
  10. 			//创建类
  11. 			Class<?> class1 = Class.forName("com.app.Person");
  13. 			//获取所有的公共的方法
  14. 			Method[] methods = 	class1.getMethods() ;
  16. 			for (Method method : methods) {
  17. 				System.out.println( method );
  18. 			}
  20. 		} catch (ClassNotFoundException e) {
  21. 			e.printStackTrace();
  22. 		}
  23. 	}
  24. }

运行结果：

  1. //自定义方法
  2. public static void com.app.Person.update()
  3. public java.lang.String com.app.Person.getName()
  4. public void com.app.Person.read()
  5. public java.lang.String com.app.Person.getId()
  6. public void com.app.Person.setName(java.lang.String)
  7. public void com.app.Person.setId(java.lang.String)
  9. //父类Object类方法
  10. public final void java.lang.Object.wait() throws java.lang.InterruptedException
  11. public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
  12. public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
  13. public boolean java.lang.Object.equals(java.lang.Object)
  14. public java.lang.String java.lang.Object.toString()
  15. public native int java.lang.Object.hashCode()
  16. public final native java.lang.Class java.lang.Object.getClass()
  17. public final native void java.lang.Object.notify()
  18. public final native void java.lang.Object.notifyAll()
  • 获取所有实现的接口：getInterfaces()
  1. package com.app;
  3. public class T1 {
  5. 	public static void main(String[] args) {
  7. 		try {
  8. 			//创建类
  9. 			Class<?> class1 = Class.forName("com.app.Person");
  11. 			//获取所有的接口
  12. 			Class<?>[] interS = class1.getInterfaces() ;
  14. 			for (Class<?> class2 : interS ) {
  15. 				System.out.println( class2 );
  16. 			}
  18. 		} catch (ClassNotFoundException e) {
  19. 			e.printStackTrace();
  20. 		}
  21. 	}
  22. }

运行结果：

  1. interface com.app.InterFace
  • 获取父类：getSuperclass()
  1. package com.app;
  3. public class T1 {
  5. 	public static void main(String[] args) {
  7. 		try {
  8. 			//创建类
  9. 			Class<?> class1 = Class.forName("com.app.Person");
  11. 			//获取父类
  12. 			Class<?> superclass = class1.getSuperclass() ;
  14. 			System.out.println( superclass );
  16. 		} catch (ClassNotFoundException e) {
  17. 			e.printStackTrace();
  18. 		}
  19. 	}
  20. }

运行结果：

  1. //父类是Object类
  2. class java.lang.Object
  • 获取所有的构造函数：getConstructors()
  1. package com.app;
  3. import java.lang.reflect.Constructor;
  5. public class T1 {
  7. 	public static void main(String[] args) {
  9. 		try {
  10. 			//创建类
  11. 			Class<?> class1 = Class.forName("com.app.Person");
  13. 			//获取所有的构造函数
  14. 			Constructor<?>[] constructors = class1.getConstructors() ;
  16. 			for (Constructor<?> constructor : constructors) {
  17. 				System.out.println( constructor );
  18. 			}
  20. 		} catch (ClassNotFoundException e) {
  21. 			e.printStackTrace();
  22. 		}
  23. 	}
  24. }

运行结果：

  1. public com.app.Person(java.lang.String,java.lang.String)
  2. public com.app.Person(java.lang.String)
  3. public com.app.Person()
  • 获取所有的属性：getDeclaredFields();
  1. package com.app;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  6. public class T1 {
  8. 	public static void main(String[] args) {
  10. 		try {
  11. 			//创建类
  12. 			Class<?> class1 = Class.forName("com.app.Person");
  14. 			//取得本类的全部属性
  15. 			Field[] field = class1.getDeclaredFields();
  17. 			for (Field field2 : field) {
  18. 				System.out.println( field2 );
  19. 			}
  21. 		} catch (ClassNotFoundException e) {
  22. 			e.printStackTrace();
  23. 		}
  24. 	}
  25. }

运行结果：

  1. private java.lang.String com.app.Person.id
  2. private java.lang.String com.app.Person.name

可以看出属性的修饰符是: private , 数据类型：String ，名字：id/name

  • 创建实例：newInstance()
  1. package com.app;
  3. public class T1 {
  5. 	public static void main(String[] args) {
  7. 		try {
  8. 			//创建类
  9. 			Class<?> class1 = Class.forName("com.app.Person");;
  11. 			//创建实例化：相当于 new 了一个对象
  12. 			Object object = class1.newInstance() ;
  14. 			//向下转型
  15. 			Person person = (Person) object ;
  17. 		} catch (ClassNotFoundException e) {
  18. 			e.printStackTrace();
  19. 		} catch (InstantiationException e) {
  20. 			e.printStackTrace();
  21. 		} catch (IllegalAccessException e) {
  22. 			e.printStackTrace();
  23. 		}
  25. 	}
  26. }

getDeclaredFields 和 getFields 的区别

getDeclaredFields()获得某个类的所有申明的字段，即包括public、private和proteced，但是不包括父类的申明字段。

getFields()获得某个类的所有的公共（public）的字段，包括父类。

小例子

  1. package com.app;
  3. import java.lang.reflect.Field;
  5. public class T1 {
  7. 	public static void main(String[] args) {
  9. 		try {
  10. 			//创建类
  11. 			Class<?> class1 = Class.forName("com.app.Person");;
  13. 			//获得所有的字段属性：包括
  14. 			Field[] declaredFields = class1.getDeclaredFields() ;
  16. 			Field[] fields = class1.getFields() ;
  18. 			for( Field field : declaredFields ){
  19. 				System.out.println( "de--  " +  field  );
  20. 			}
  22. 			for( Field field : fields ){
  23. 				System.out.println( "fields--  " +  field  );
  24. 			}
  26. 		} catch (ClassNotFoundException e) {
  27. 			e.printStackTrace();
  28. 		}
  30. 	}
  31. }

运行结果：

  1. de--  private java.lang.String com.app.Person.id
  2. de--  private java.lang.String com.app.Person.name
  3. de--  public java.lang.String com.app.Person.age
  4. fields--  public java.lang.String com.app.Person.age

实战1：通过反射，获取对象实例，并且操作对象的方法

  1. package com.app;
  3. public class T1 {
  5. 	public static void main(String[] args) {
  7. 		try {
  8. 			//创建类
  9. 			Class<?> class1 = Class.forName("com.app.Person");;
  11. 			//创建实例化：相当于 new 了一个对象
  12. 			Object object = class1.newInstance() ;
  14. 			//向下转型
  15. 			Person person = (Person) object ;
  17. 			person.setId( "100");
  18. 			person.setName( "jack") ; 
  20. 			System.out.println( "id: " + person.getId() + " name: " + person.getName()  );
  22. 		} catch (ClassNotFoundException e) {
  23. 			e.printStackTrace();
  24. 		} catch (InstantiationException e) {
  25. 			e.printStackTrace();
  26. 		} catch (IllegalAccessException e) {
  27. 			e.printStackTrace();
  28. 		}
  30. 	}
  31. }

运行结果：

  1. id: 100 name: jack

实战2：通过反射获取对象字段属性，并且赋值

  1. package com.app;
  3. import java.lang.reflect.Field;
  5. public class T1 {
  7. 	public static void main(String[] args) {
  9. 		try {
  10. 			//创建类
  11. 			Class<?> class1 = Class.forName("com.app.Person");
  13. 			//创建实例
  14. 			Object person = class1.newInstance();
  16. 			//获得id 属性
  17. 			Field idField = class1.getDeclaredField( "id" ) ;
  19. 			//给id 属性赋值
  20. 			idField.set(  person , "100") ;
  22. 			//打印 person 的属性值
  23. 			System.out.println( idField.get( person ));
  25. 		} catch (InstantiationException e) {
  26. 			e.printStackTrace();
  27. 		} catch (IllegalAccessException e) {
  28. 			e.printStackTrace();
  29. 		} catch (NoSuchFieldException e) {
  30. 			e.printStackTrace();
  31. 		} catch (SecurityException e) {
  32. 			e.printStackTrace() ;
  33. 		} catch (ClassNotFoundException e) {
  34. 			e.printStackTrace();
  35. 		}
  37. 	}
  38. }

运行结果：

  1. java.lang.IllegalAccessException: Class com.app.T1 can not access a member of class com.app.Person with modifiers "private"
  2. 	at sun.reflect.Reflection.ensureMemberAccess(Unknown Source)
  3. 	at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(Unknown Source)
  4. 	at java.lang.reflect.AccessibleObject.checkAccess(Unknown Source)
  5. 	at java.lang.reflect.Field.set(Unknown Source)
  6. 	at com.app.T1.main(T1.java:20)

程序崩溃，原因是：id 这个属性的是 private 私有的，不能修改它的值。

改进：

添加 idField.setAccessible( true );

完整的代码为：

  1. package com.app;
  3. import java.lang.reflect.Field;
  5. public class T1 {
  7. 	public static void main(String[] args) {
  9. 		try {
  10. 			//创建类
  11. 			Class<?> class1 = Class.forName("com.app.Person");
  13. 			//创建实例
  14. 			Object person = class1.newInstance();
  16. 			//获得id 属性
  17. 			Field idField = class1.getDeclaredField( "id" ) ;
  19. 			//打破封装  实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问
  20.             //由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的
  21. 			idField.setAccessible( true );
  23. 			//给id 属性赋值
  24. 			idField.set(  person , "100") ;
  26. 			//打印 person 的属性值
  27. 			System.out.println( idField.get( person ));
  29. 		} catch (InstantiationException e) {
  30. 			e.printStackTrace();
  31. 		} catch (IllegalAccessException e) {
  32. 			e.printStackTrace();
  33. 		} catch (NoSuchFieldException e) {
  34. 			e.printStackTrace();
  35. 		} catch (SecurityException e) {
  36. 			e.printStackTrace() ;
  37. 		} catch (ClassNotFoundException e) {
  38. 			e.printStackTrace();
  39. 		}
  41. 	}
  42. }

运行结果：

  1. 100

实战3：综合训练，反射操作属性和方法

  1. package com.app;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  7. public class T1 {
  9. 	public static void main(String[] args) {
  11. 		try {
  12. 			//创建类
  13. 			Class<?> class1 = Class.forName("com.app.Person");
  15. 			//创建实例
  16. 			Object person = class1.newInstance();
  18. 			//获得id 属性
  19. 			Field idField = class1.getDeclaredField( "id" ) ;
  21. 			//打破封装  实际上setAccessible是启用和禁用访问安全检查的开关,并不是为true就能访问为false就不能访问
  22. 			//由于JDK的安全检查耗时较多.所以通过setAccessible(true)的方式关闭安全检查就可以达到提升反射速度的目的
  23. 			idField.setAccessible( true );
  25. 			//给id 属性赋值
  26. 			idField.set(  person , "100") ;
  28. 			//获取 setName() 方法
  29. 			Method setName = class1.getDeclaredMethod( "setName", String.class ) ;
  30. 			//打破封装
  31. 			setName.setAccessible( true );
  33. 			//调用setName 方法。
  34. 			setName.invoke( person , "jack" ) ;
  36. 			//获取name 字段
  37. 			Field nameField = class1.getDeclaredField( "name" ) ;
  38. 			//打破封装
  39. 			nameField.setAccessible( true );
  41. 			//打印 person 的 id 属性值
  42. 			String id_ = (String) idField.get( person ) ;
  43. 			System.out.println( "id: " + id_ );
  45. 			//打印 person 的 name 属性值
  46. 			String name_ = ( String)nameField.get( person ) ;
  47. 			System.out.println( "name: " + name_ );
  49. 			//获取 getName 方法
  50. 			Method getName = class1.getDeclaredMethod( "getName" ) ;
  51. 			//打破封装
  52. 			getName.setAccessible( true );
  54. 			//执行getName方法，并且接收返回值
  55. 			String name_2 = (String) getName.invoke( person  ) ;
  56. 			System.out.println( "name2: " + name_2 );
  58. 		} catch (IllegalArgumentException e) {
  59. 			e.printStackTrace();
  60. 		} catch (InvocationTargetException e) {
  61. 			e.printStackTrace();
  62. 		} catch (NoSuchMethodException e) {
  63. 			e.printStackTrace();
  64. 		} catch (InstantiationException e) {
  65. 			e.printStackTrace();
  66. 		} catch (IllegalAccessException e) {
  67. 			e.printStackTrace();
  68. 		} catch (NoSuchFieldException e) {
  69. 			e.printStackTrace();
  70. 		} catch (SecurityException e) {
  71. 			e.printStackTrace() ;
  72. 		} catch (ClassNotFoundException e) {
  73. 			e.printStackTrace();
  74. 		}
  76. 	}
  77. }

运行结果：

  1. id: 100
  2. name: jack
  3. name2: jack

实战4：静态属性、静态方法调用

定义 Util 类

  1. package com.app;
  3. public class Util {
  5. 	public static String name = "json" ;
  7. 	/**
  8. 	 * 没有返回值，没有参数
  9. 	 */
  10. 	public static void getTips(){
  11. 		System.out.println( "执行了---------1111");
  12. 	}
  14. 	/**
  15. 	 * 有返回值，没有参数
  16. 	 */
  17. 	public static String getTip(){
  18. 		System.out.println( "执行了---------2222");
  19. 		return "tip2" ;
  20. 	}
  22. 	/**
  23. 	 * 没有返回值，有参数
  24. 	 * @param name
  25. 	 */
  26. 	public static void getTip( String name ){
  27. 		System.out.println( "执行了---------3333 参数： " + name );
  28. 	}
  30. 	/**
  31. 	 * 有返回值，有参数
  32. 	 * @param id
  33. 	 * @return
  34. 	 */
  35. 	public static String getTip( int id ){
  36. 		System.out.println( "执行了---------4444 参数： " + id );
  37. 		if ( id == 0 ){
  38. 			return "tip1 444 --1 " ;
  39. 		}else{
  40. 			return "tip1 444 --2" ;
  41. 		}
  42. 	}
  44. }

完整小例子：

  1. package com.app;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  7. public class T1 {
  9. 	public static void main(String[] args) {
  11. 		try {
  12. 			//创建类
  13. 			Class<?> class1 = Class.forName("com.app.Util");
  15. 			//获取 nameField 属性
  16. 			Field nameField = class1.getDeclaredField( "name" ) ;
  17. 			//获取 nameField 的值
  18. 			String name_ = (String) nameField.get( nameField ) ;
  19. 			//输出值
  20. 			System.out.println( name_ );
  22. 			//没有返回值，没有参数
  23. 			Method getTipMethod1 = class1.getDeclaredMethod( "getTips"  ) ;
  24. 			getTipMethod1.invoke( null  ) ;
  26. 			//有返回值，没有参数
  27. 			Method getTipMethod2 = class1.getDeclaredMethod( "getTip"  ) ;
  28. 			String result_2 = (String) getTipMethod2.invoke( null  ) ;
  29. 			System.out.println( "返回值： "+ result_2 );
  31. 			//没有返回值，有参数
  32. 			Method getTipMethod3 = class1.getDeclaredMethod( "getTip" , String.class  ) ;
  33. 			String result_3 = (String) getTipMethod3.invoke( null , "第三个方法"  ) ;
  34. 			System.out.println( "返回值： "+ result_3 );
  36. 			//有返回值，有参数
  37. 			Method getTipMethod4 = class1.getDeclaredMethod( "getTip" , int.class ) ;
  38. 			String result_4 = (String) getTipMethod4.invoke( null  , 1 ) ;
  39. 			System.out.println( "返回值： "+ result_4 );
  41. 		} catch (InvocationTargetException e) {
  42. 			e.printStackTrace();
  43. 		} catch (IllegalArgumentException e) {
  44. 			e.printStackTrace();
  45. 		} catch (NoSuchMethodException e) {
  46. 			e.printStackTrace();
  47. 		} catch (IllegalAccessException e) {
  48. 			e.printStackTrace();
  49. 		} catch (NoSuchFieldException e) {
  50. 			e.printStackTrace();
  51. 		} catch (SecurityException e) {
  52. 			e.printStackTrace() ;
  53. 		} catch (ClassNotFoundException e) {
  54. 			e.printStackTrace();
  55. 		}
  57. 	}
  58. }

运行结果：

  1. json
  2. 执行了---------1111
  3. 执行了---------2222
  4. 返回值： tip2
  5. 执行了---------3333 参数： 第三个方法
  6. 返回值： null
  7. 执行了---------4444 参数： 1
  8. 返回值： tip1 444 --2

当参数是 int 类型 和 Integer 类型，反射获取方法不一样

  • 当参数是 int 类型时
  1.     /**
  2. 	 * 没有返回值，有参数
  3. 	 * @param id
  4. 	 */
  5. 	public static void getTip( int id ){
  7. 	}

获取方法的时候需要用：int.class。不能使用 Integer.class. 会报错。

  1. Method getTipMethod4 = class.getDeclaredMethod( "getTip" , int.class ) ;
  2. String result_4 = (String) getTipMethod4.invoke( null  , 1 ) ;
  3. System.out.println( "返回值： "+ result_4 );
  • 当参数是 Integer类型时
  1.     /**
  2. 	 * 没有返回值，有参数
  3. 	 * @param id
  4. 	 */
  5. 	public static void getTip( Integer id ){
  7. 	}

获取方法的时候需要用：Integer .class。不能使用 int.class. 会报错。

  1. Method getTipMethod4 = class.getDeclaredMethod( "getTip" , Integer .class ) ;
  2. String result_4 = (String) getTipMethod4.invoke( null  , 1 ) ;
  3. System.out.println( "返回值： "+ result_4 );

创建对象实例

Person 类

  1. package com.app;
  3. public class Person{
  5. 	private String id ;
  7. 	private String name ;
  9. 	//构造函数1
  10. 	public Person( ){
  11. 		System.out.println( "构造函数  无参" );
  12. 	}
  14. 	//构造函数2
  15. 	public Person( String id ){
  16. 		this.id = id ;
  17. 		System.out.println( "构造函数 id : " + id );
  18. 	}
  20. 	//构造函数3
  21. 	public Person( String id  , String name ){
  22. 		this.id = id ;
  23. 		this.name = name ;
  24. 		System.out.println( "构造函数 id : " + id  + " name: " + name );
  25. 	}
  27. 	public String getId() {
  28. 		return id;
  29. 	}
  31. 	public void setId(String id) {
  32. 		this.id = id;
  33. 	}
  35. 	public String getName() {
  36. 		return name;
  37. 	}
  39. 	public void setName(String name) {
  40. 		this.name = name;
  41. 	}
  43. }

创建实例实战

  1. package com.app;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.InvocationTargetException;
  6. public class T1 {
  8. 	public static void main(String[] args) {
  10. 		try {
  12. 			//创建类
  13. 			Class<?> class1 = Class.forName("com.app.Person");
  15. 			//无参构造函数
  16. 			Object object = class1.newInstance() ;
  18. 			//有参构造函数：一个参数
  19. 			Constructor<?> constructor =  class1.getDeclaredConstructor( String.class ) ;
  20. 			constructor.newInstance( "1000" ) ;
  22. 			//有参构造函数：二个参数
  23. 			Constructor<?> constructor2 =  class1.getDeclaredConstructor( String.class , String.class ) ;
  24. 			constructor2.newInstance( "1001" , "jack" ) ;
  26. 		} catch (InstantiationException e) {
  27. 			e.printStackTrace();
  28. 		} catch (IllegalAccessException e) {
  29. 			e.printStackTrace();
  30. 		} catch (InvocationTargetException e) {
  31. 			e.printStackTrace();
  32. 		} catch (IllegalArgumentException e) {
  33. 			e.printStackTrace();
  34. 		} catch (NoSuchMethodException e) {
  35. 			e.printStackTrace();
  36. 		} catch (SecurityException e) {
  37. 			e.printStackTrace() ;
  38. 		} catch (ClassNotFoundException e) {
  39. 			e.printStackTrace();
  40. 		}
  42. 	}
  43. }

运行结果

  1. 构造函数  无参
  2. 构造函数 id : 1000
  3. 构造函数 id : 1001 name: jack

总结

  • Class类提供了四个public方法，用于获取某个类的构造方法。
  1. Constructor getConstructor(Class[] params)     根据构造函数的参数，返回一个具体的具有public属性的构造函数
  2. Constructor getConstructors()     返回所有具有public属性的构造函数数组
  3. Constructor getDeclaredConstructor(Class[] params)     根据构造函数的参数，返回一个具体的构造函数（不分public和非public属性）
  4. Constructor getDeclaredConstructors()    返回该类中所有的构造函数数组（不分public和非public属性）
  • 四种获取成员方法的方法
  1. Method getMethod(String name, Class[] params)    根据方法名和参数，返回一个具体的具有public属性的方法
  2. Method[] getMethods()    返回所有具有public属性的方法数组
  3. Method getDeclaredMethod(String name, Class[] params)    根据方法名和参数，返回一个具体的方法（不分public和非public属性）
  4. Method[] getDeclaredMethods()    返回该类中的所有的方法数组（不分public和非public属性）
  • 四种获取成员属性的方法
  1. Field getField(String name)    根据变量名，返回一个具体的具有public属性的成员变量
  2. Field[] getFields()    返回具有public属性的成员变量的数组
  3. Field getDeclaredField(String name)    根据变量名，返回一个成员变量（不分public和非public属性）
  4. Field[] getDelcaredField()    返回所有成员变量组成的数组（不分public和非public属性）

Java 反射 使用总结的更多相关文章

  1. 第28章 java反射机制

    java反射机制 1.类加载机制 1.1.jvm和类 运行Java程序:java 带有main方法的类名 之后java会启动jvm,并加载字节码(字节码就是一个类在内存空间的状态) 当调用java命令 ...

  2. Java反射机制

    Java反射机制 一:什么事反射机制 简单地说,就是程序运行时能够通过反射的到类的所有信息,只需要获得类名,方法名,属性名. 二:为什么要用反射:     静态编译:在编译时确定类型,绑定对象,即通过 ...

  3. java反射(基础了解)

    package cn.itcast_01; /** *Person类 */ public class Person {    /** 姓名 */    private String name;     ...

  4. java基础知识（十一）java反射机制（上）

    java.lang.Class类详解 java Class类详解 一.class类 Class类是java语言定义的特定类的实现,在java中每个类都有一个相应的Class对象,以便java程序运行时 ...

  5. java基础知识（十一）java反射机制（下）

    1.什么是反射机制? java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象都能够调用他的属性和方法,这种动态获取属性和方法的功能称为java的反射机制. ...

  6. java反射学习之二万能EXCEL导出

    一.EXCEL导出的实现过程 假设有一个对象的集合,现在需要将此集合内的所有对象导出到EXCEL中,对象有N个属性:那么我们实现的方式是这样的: 循环这个集合,在循环集合中某个对象的所有属性,将这个对 ...

  7. java反射学习之一反射机制概述

    一.反射机制背景概述 1.反射(reflection)是java被视为动态语言的一个关键性质 2.反射机制指的是程序在运行时能获取任何类的内部所有信息 二.反射机制实现功能概述 1.只要给定类的全名, ...

  8. java反射 之 反射基础

    一.反射 反射:JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为 ...

  9. java反射 cglib asm相关资料

    有篇文章对java反射的调用的效率做了测试,写的比较好.猛击下面地址 http://www.blogjava.net/stone2083/archive/2010/09/15/332065.html ...

  10. 超详细的java反射教程

    看技术博客时,看到关于java反射的博文,写的非常好.猛击下面的地址,开始java反射之旅 中文翻译地址:http://ifeve.com/java-reflection/ 英文原版地址:http:/ ...

随机推荐

  1. Xamarin.Android广播接收器与绑定服务

    一.前言 学习了前面的活动与服务后,你会发现服务对于活动而言似乎就是透明的,相反活动对于服务也是透明的,所以我们还需要一中机制能够将服务和活动之间架起一座桥梁,通过本节的学习,你将会学到广播与绑定服务 ...

  2. 深入理解jQuery、Angular、node中的Promise

    最初遇到Promise是在jQuery中,在jQuery1.5版本中引入了Deferred Object,这个异步队列模块用于实现异步任务和回调函数的解耦.为ajax模块.队列模块.ready事件提供 ...

  3. Go build constraints

    Go语言有一个不(奇)错(葩)的设计,就是build constraints(构建约束).可以在源码中通过注释的方式指定编译选项,比如只允许在linux下,或者在386的平台上编译啊之类的:还可以通过 ...

  4. 更有效率的使用Visual Studio（二）

    没想到上一篇文章有这么多人喜欢,多谢大家支持.继续- 很多比较通用的快捷键的默认设置其实是有一些缩写在里面的,这个估计也是MS帮助我们记忆.比如说注释代码的快捷键是Ctrl + E + C,我们如果知 ...

  5. ABP源码分析四十：ZERO的Application和Tenant

    ABP的Zero模块以数据库为数据源实现了ABP框架中的tenant management (multi-tenancy), role management, user management, ses ...

  6. 在面试中忽然发现DateTime的一些...

    今天说说我面试中碰到的一个小问题,在我问起DateTime为什么无法赋值NULL值,一般第一反应都认为它是值类型,不是引用类型,但随后我查阅了度娘自我学习到它是结构类型,那么随之而然就无法赋值NULL ...

  7. 严重: Null component localEngine:type=JspMonitor,name=jsp,WebModule=//localhost/SpringMVC01,J2EEApplication=none,J2EEServer=none

    检查了 Java Build Path, Java Compiler,Project Facts 都确定了版本一致 包括 maven run as →run config 里面的 jdk 和maven ...

  8. ASP.NET MVC5+EF6+EasyUI 后台管理系统（58）-DAL层重构

    系列目录 前言:这是对本文系统一次重要的革新,很久就想要重构数据访问层了,数据访问层重复代码太多.主要集中增删该查每个模块都有,所以本次是为封装相同接口方法 如果你想了解怎么重构普通的接口DAL层请查 ...

  9. [C#] 走进异步编程的世界 - 在 GUI 中执行异步操作

    走进异步编程的世界 - 在 GUI 中执行异步操作 [博主]反骨仔 [原文地址]http://www.cnblogs.com/liqingwen/p/5877042.html 序 这是继<开始接 ...

  10. 如何通过官方渠道为Windows 10 添加具有中国特色的字体

    Windows 10的变化细节上个人认为要比Windows 8多很多,而且很多功能找到之后还是小惊喜,就是挺多好用的地方居然都不正经宣传一下,微软真是搞得悄悄地干活? 今天为大家介绍一下通过官方途径添 ...