java反射机制——getMethod/getField与getDeclaredMethod/getDeclaredField区别

最新推荐文章于 2025-06-19 13:52:47 发布
最新推荐文章于 2025-06-19 13:52:47 发布
阅读量1.5k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/MyEHomeARM/article/details/52461717
本文探讨了Java反射中的getMethod和getDeclaredMethod的区别，重点在于它们对访问权限的处理。通过测试代码展示了即使在父类中，只有public方法和字段才能被getMethod获取，而getDeclaredMethod则能获取到类声明的所有方法，包括非public的。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

测试代码：

package com.jason.corejava.reflex;

import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflexMain {
	
	public static void main(String[] args) throws IOException{
		Log log = Log.createLog("C:\\Users\\kdhfkd\\logText.txt");
		
		log.print("---------now is getMethod and getField---------");
		
		Class<?> classA = ObjectA.class;
		try {
			Object objectA = classA.newInstance();
			log.print("objectA created\r\n");
			
			try {
				Method setFieldA = classA.getMethod("setFieldA", String.class);
				setFieldA.invoke(objectA, "getMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classA.getMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectA);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classA.getMethod("setFieldB", String.class);
				setFieldB.invoke(objectA, "getMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classA.getMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectA);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classA.getMethod("setFieldC", String.class);
				setFieldC.invoke(objectA, "getMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classA.getMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectA);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getField("fieldA");
				String result = (String) fieldA.get(objectA);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getField("fieldB");
				String result = (String) fieldB.get(objectA);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getField("fieldC");
				String result = (String) fieldC.get(objectA);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectA err:"+e.toString()+"\r\n");
		}
		
		Class<?> classB = ObjectB.class;
		try {
			Object objectB = classB.newInstance();
			log.print("objectB created\r\n");
			
			try {
				Method setFieldA = classB.getMethod("setFieldA", String.class);
				setFieldA.invoke(objectB, "getMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classB.getMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectB);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classB.getMethod("setFieldB", String.class);
				setFieldB.invoke(objectB, "getMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classB.getMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectB);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classB.getMethod("setFieldC", String.class);
				setFieldC.invoke(objectB, "getMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classB.getMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectB);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldD = classB.getMethod("setFieldD", String.class);
				setFieldD.invoke(objectB, "getMethod");
				log.print("setFieldD ok\r\n");
				Method getFieldD = classB.getMethod("getFieldD");
				String result = (String) getFieldD.invoke(objectB);
				log.print("getFieldD ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldD get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldE = classB.getMethod("setFieldE", String.class);
				setFieldE.invoke(objectB, "getMethod");
				log.print("setFieldE ok\r\n");
				Method getFieldE = classB.getMethod("getFieldE");
				String result = (String) getFieldE.invoke(objectB);
				log.print("getFieldE ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldE get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getField("fieldA");
				String result = (String) fieldA.get(objectB);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getField("fieldB");
				String result = (String) fieldB.get(objectB);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getField("fieldC");
				String result = (String) fieldC.get(objectB);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectB err:"+e.toString());
		}
		
		Class<?> classC = ObjectC.class;
		try {
			Object objectC = classC.newInstance();
			log.print("objectC created\r\n");
			
			try {
				Method setFieldA = classC.getMethod("setFieldA", String.class);
				setFieldA.invoke(objectC, "getMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classC.getMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectC);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classC.getMethod("setFieldB", String.class);
				setFieldB.invoke(objectC, "getMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classC.getMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectC);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classC.getMethod("setFieldC", String.class);
				setFieldC.invoke(objectC, "getMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classC.getMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectC);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getField("fieldA");
				String result = (String) fieldA.get(objectC);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getField("fieldB");
				String result = (String) fieldB.get(objectC);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getField("fieldC");
				String result = (String) fieldC.get(objectC);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectC err:"+e.toString());
		}
		
		/**
		 * TODO
		 */
		log.print("---------now is getDeclaredMethod and getDeclaredField---------");
		
		try {
			Object objectA = classA.newInstance();
			log.print("objectA created\r\n");
			
			try {
				Method setFieldA = classA.getDeclaredMethod("setFieldA", String.class);
				setFieldA.invoke(objectA, "getDeclaredMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classA.getDeclaredMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectA);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classA.getDeclaredMethod("setFieldB", String.class);
				setFieldB.invoke(objectA, "getDeclaredMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classA.getDeclaredMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectA);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classA.getDeclaredMethod("setFieldC", String.class);
				setFieldC.invoke(objectA, "getDeclaredMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classA.getDeclaredMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectA);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException 
					| IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getDeclaredField("fieldA");
				String result = (String) fieldA.get(objectA);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getDeclaredField("fieldB");
				String result = (String) fieldB.get(objectA);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getDeclaredField("fieldC");
				String result = (String) fieldC.get(objectA);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectA err:"+e.toString()+"\r\n");
		}
		
		try {
			Object objectB = classB.newInstance();
			log.print("objectB created\r\n");
			
			try {
				Method setFieldA = classB.getDeclaredMethod("setFieldA", String.class);
				setFieldA.invoke(objectB, "getDeclaredMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classB.getDeclaredMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectB);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classB.getDeclaredMethod("setFieldB", String.class);
				setFieldB.invoke(objectB, "getDeclaredMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classB.getDeclaredMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectB);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classB.getDeclaredMethod("setFieldC", String.class);
				setFieldC.invoke(objectB, "getDeclaredMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classB.getDeclaredMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectB);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldD = classB.getDeclaredMethod("setFieldD", String.class);
				setFieldD.invoke(objectB, "getDeclaredMethod");
				log.print("setFieldD ok\r\n");
				Method getFieldD = classB.getDeclaredMethod("getFieldD");
				String result = (String) getFieldD.invoke(objectB);
				log.print("getFieldD ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldD get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldE = classB.getDeclaredMethod("setFieldE", String.class);
				setFieldE.invoke(objectB, "getDeclaredMethod");
				log.print("setFieldE ok\r\n");
				Method getFieldE = classB.getDeclaredMethod("getFieldE");
				String result = (String) getFieldE.invoke(objectB);
				log.print("getFieldE ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldE get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getDeclaredField("fieldA");
				String result = (String) fieldA.get(objectB);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getDeclaredField("fieldB");
				String result = (String) fieldB.get(objectB);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getDeclaredField("fieldC");
				String result = (String) fieldC.get(objectB);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectB err:"+e.toString());
		}
		
		try {
			Object objectC = classC.newInstance();
			log.print("objectC created\r\n");
			
			try {
				Method setFieldA = classC.getDeclaredMethod("setFieldA", String.class);
				setFieldA.invoke(objectC, "getDeclaredMethod");
				log.print("setFieldA ok\r\n");
				Method getFieldA = classC.getDeclaredMethod("getFieldA");
				String result = (String) getFieldA.invoke(objectC);
				log.print("getFieldA ok result = " + result + "\r\n");
				
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldB = classC.getDeclaredMethod("setFieldB", String.class);
				setFieldB.invoke(objectC, "getDeclaredMethod");
				log.print("setFieldB ok\r\n");
				Method getFieldB = classC.getDeclaredMethod("getFieldB");
				String result = (String) getFieldB.invoke(objectC);
				log.print("getFieldB ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Method setFieldC = classC.getDeclaredMethod("setFieldC", String.class);
				setFieldC.invoke(objectC, "getDeclaredMethod");
				log.print("setFieldC ok\r\n");
				Method getFieldC = classC.getDeclaredMethod("getFieldC");
				String result = (String) getFieldC.invoke(objectC);
				log.print("getFieldC ok result = " + result + "\r\n");
			} catch (NoSuchMethodException | SecurityException | IllegalArgumentException | InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get/set err:"+e.toString()+"\r\n");
			}
			
			try {
				Field fieldA = classA.getDeclaredField("fieldA");
				String result = (String) fieldA.get(objectC);
				log.print("fieldA = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldA get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldB = classA.getDeclaredField("fieldB");
				String result = (String) fieldB.get(objectC);
				log.print("fieldB = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldB get fail:" + e.toString() + "\r\n");
			}
			
			try {
				Field fieldC = classA.getDeclaredField("fieldC");
				String result = (String) fieldC.get(objectC);
				log.print("fieldC = " + result + "\r\n");
			} catch (NoSuchFieldException | SecurityException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				log.print("fieldC get fail:" + e.toString() + "\r\n");
			}
			
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			log.print("objectC err:"+e.toString());
		}
	}
	
}

其中ObjectA、ObjectB和ObjectC三个类

1）ObjectA

package com.jason.corejava.reflex;

public class ObjectA {
	
	public String fieldA;
	protected String fieldB;
	private String fieldC;
	
	private String fieldD;
	
	private String fieldE;
	
	public String getFieldA() {
		return fieldA;
	}
	public void setFieldA(String fieldA) {
		this.fieldA = fieldA;
	}
	
	protected String getFieldB() {
		return fieldB;
	}
	
	protected void setFieldB(String fieldB) {
		this.fieldB = fieldB;
	}
	
	private String getFieldC() {
		return fieldC;
	}
	
	private void setFieldC(String fieldC) {
		this.fieldC = fieldC;
	}
	
	
	public String getFieldD() {
		return fieldD;
	}
	
	public void setFieldD(String fieldD) {
		this.fieldD = fieldD;
	}
	
	protected String getFieldE() {
		return fieldE;
	}
	
	protected void setFieldE(String fieldE) {
		this.fieldE = fieldE;
	}
	
	
}
2）ObjectB 

package com.jason.corejava.reflex;

public class ObjectB extends ObjectA {
	
	@Override
	public String getFieldD() {
		return super.getFieldD();
	}
	@Override
	public void setFieldD(String fieldD) {
		super.setFieldD(fieldD);
	}
	
	@Override
	protected String getFieldE() {
		// TODO Auto-generated method stub
		return super.getFieldE();
	}
	@Override
	protected void setFieldE(String fieldE) {
		// TODO Auto-generated method stub
		super.setFieldE(fieldE);
	}
	
	
}

3）ObjectC 

package com.jason.corejava.reflex;

public class ObjectC extends ObjectB {
	
	
}

运行打印结果到logText.txt 

---------now is getMethod and getField---------objectA created
setFieldA ok
getFieldA ok result = getMethod
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectA.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectA.setFieldC(java.lang.String)
fieldA = getMethod
fieldB get fail:java.lang.NoSuchFieldException: fieldB
fieldC get fail:java.lang.NoSuchFieldException: fieldC
objectB created
setFieldA ok
getFieldA ok result = getMethod
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldC(java.lang.String)
setFieldD ok
getFieldD ok result = getMethod
fieldE get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldE(java.lang.String)
fieldA = getMethod
fieldB get fail:java.lang.NoSuchFieldException: fieldB
fieldC get fail:java.lang.NoSuchFieldException: fieldC
objectC created
setFieldA ok
getFieldA ok result = getMethod
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectC.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectC.setFieldC(java.lang.String)
fieldA = getMethod
fieldB get fail:java.lang.NoSuchFieldException: fieldB
fieldC get fail:java.lang.NoSuchFieldException: fieldC
---------now is getDeclaredMethod and getDeclaredField---------objectA created
setFieldA ok
getFieldA ok result = getDeclaredMethod
setFieldB ok
getFieldB ok result = getDeclaredMethod
fieldC get/set err:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
fieldA = getDeclaredMethod
fieldB = getDeclaredMethod
fieldC get fail:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
objectB created
fieldA get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldA(java.lang.String)
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldC(java.lang.String)
setFieldD ok
getFieldD ok result = getDeclaredMethod
setFieldE ok
getFieldE ok result = getDeclaredMethod
fieldA = null
fieldB = null
fieldC get fail:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
objectC created
fieldA get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectC.setFieldA(java.lang.String)
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectC.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectC.setFieldC(java.lang.String)
fieldA = null
fieldB = null
fieldC get fail:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"

分析：

1. 无论声明在本类还是父类，调用getMethod/getField，只有public的方法/字段才能访问

<pre name="code" class="plain">---------now is getMethod and getField---------
objectA created
setFieldA ok
getFieldA ok result = getMethod
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectA.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectA.setFieldC(java.lang.String)
fieldA = getMethod
fieldB get fail:java.lang.NoSuchFieldException: fieldB
fieldC get fail:java.lang.NoSuchFieldException: fieldC
objectB created
setFieldA ok
getFieldA ok result = getMethod
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldC(java.lang.String)
fieldA = getMethod
fieldB get fail:java.lang.NoSuchFieldException: fieldB
fieldC get fail:java.lang.NoSuchFieldException: fieldC
2. 若声明在本类，调用getDeclaredMethod，public和protected的方法能够访问 


<pre name="code" class="plain">setFieldA ok
getFieldA ok result = getDeclaredMethod
setFieldB ok
getFieldB ok result = getDeclaredMethod
fieldC get/set err:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
3. 若声明在父类，调用getDeclaredMethod，所有方法都不能访问



<pre name="code" class="plain"><pre name="code" class="plain">fieldA get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldA(java.lang.String)
fieldB get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldB(java.lang.String)
fieldC get/set err:java.lang.NoSuchMethodException: com.jason.corejava.reflex.ObjectB.setFieldC(java.lang.String)
4. 无论声明在父类还是子类，调用getDeclaredField，public和protected的字段能够访问


fieldA = getDeclaredMethod
fieldB = getDeclaredMethod
fieldC get fail:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
fieldA = null
fieldB = null
fieldC get fail:java.lang.IllegalAccessException: Class com.jason.corejava.reflex.ReflexMain can not access a member of class com.jason.corejava.reflex.ObjectA with modifiers "private"
























                

        

    

    
  



    



                



	

		

			

				
					
反射实例——JAVA反射机制

				
			

			

				

					Java_supermanNO1的博客
				

				

					03-18
					
					576
					
				

			

		

		

			
				
本文转载自：反射实例——JAVA反射机制

一、Java反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的...

			
		

	



                

            
              



	

		

			

				
					
Java 反射机制

				
			

			

				

					水w的博客
				

				

					10-08
					
					1082
					
				

			

		

		

			
				
Java 反射机制

			
		

	



              


  
              

                


	

		

			

				
					
反射之getDeclaredMethod和getMethod的区别以及一些小技巧

					
热门推荐

				
			

			

				

					GuoCong666的博客
				

				

					01-22
					
					3万+
					
				

			

		

		

			
				
区别
getDeclaredMethod：获取当前类的所有声明的方法，包括public、protected和private修饰的方法。需要注意的是，这些方法一定是在当前类中声明的，从父类中继承的不算，实现接口的方法由于有声明所以包括在内。


getMethod：获取当前类和父类的所有public的方法。这里的父类，指的是继承层次中的所有父类。比如说，A继承B，B继承C，那么B和C都属于A

			
		

	





	

		

			

				
					
getDeclaredMethod和getMethod的区别

				
			

			

				

					安善良民弱女子的博客
				

				

					11-09
					
					1820
					
				

			

		

		

			
				
getDeclaredMethod和getMethod的区别：getDeclaredMethod*()获取的是类自身声明的所有方法，包含public、protected和private方法。 
getMethod*()获取的是类的所有共有方法，这就包括自身的所有public方法，和从基类继承的、从接口实现的所有public方法.ApplicationContext context = null ;

			
		

	



		

			
		



	

		

			

				
					
java Class类反射getDeclaredMethod() 和 getMethod()的区别

				
			

			

				

					想到就写点东西的博客
				

				

					06-19
					
					179
					
				

			

		

		

			
				
经过排查，获取类使用的方法是getDeclaredMethod，该方法不能获取继承类的方法，改成getMethod后问题解决了。顺便整理一下两者的区别，给自己加深下印象。简单的说就是getMethod获取的是公有方法，包含继承；getDeclaredMethod获取的是该类的所有方法，包含私有方法；前几天遇到一个问题，部分业务一直报错java.lang.NoSuchMethodException，可是其它业务都是正常的啊，为什么呢？java.lang.NoSuchMethodException的报错。

			
		

	





	

		

			

				
					
关于getDeclaredMethods与getMethods的的区别

				
			

			

				

					u011235543的博客
				

				

					06-30
					
					9934
					
				

			

		

		

			
				
1、getMethods返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口的公共 member 方法。
2、getDeclaredMethods返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
也就是说getDeclaredMethods能拿

			
		

	





	

		

			

				
					
【Java反射-56.4.1】Java 中的 getDeclaredMethod() 方法：使用与原理详解

				
			

			

				

					weixin_39033358的博客
				

				

					01-04
					
					1592
					
				

			

		

		

			
				
是参数name：方法的名称。：方法的参数类型列表（可变参数）。返回值返回一个Method对象，表示类中声明的指定方法。异常：如果未找到指定方法。：如果存在安全管理器且拒绝访问。是 Java 反射机制中的一个重要方法，能够动态获取类中声明的所有方法（包括私有方法）。通过，可以实现许多强大的功能，如单元测试、框架开发和动态代理。然而，反射操作有一定的性能开销和安全隐患，需根据实际需求谨慎使用。

			
		

	





	

		

			

				
					
getDeclaredFields，getFields，getDeclaredMethods，getMethods实例测试！

				
			

			

				

					chaoyz
				

				

					06-03
					
					696
					
				

			

		

		

			
				
今日学习Class类中几个常用的方法getDeclaredFields，getFields，getDeclaredMethod，getMethod。接下来来看看他们都有什么用 
1、getFields 
返回的也是一个Field数组，数组中是当前类，其父类和所实现的接口中的public成员变量。（只有public的偶~~~） 
2、getDeclaredFields 
简明扼要的说就是返回一个Fie

			
		

	





	

		

			

				
					
getDeclaredMethod和getMethod区别，getDeclaredField和getField区别

					
最新发布

				
			

			

				

					07-10
				

			

		

		

			
				
首先，用户的问题是：“我想理解Java反射API中getDeclaredMethod与getMethod、getDeclaredField与getField之间的区别”。这涉及到Java反射机制的核心方法。  我需要基于系统级指令回答： - 所有行内数学表达式用$......

			
		

	





	

		

			

				
					
Java反射机制的讲解

				
			

			

				

					08-26
				

			

		

		

			
				
Java反射机制的讲解  Java反射机制是一种运行期获取对象元信息的手段，它允许在Java运行时环境中，对于任意一个类，可以知道这个类有哪些属性和方法。同时，它也允许在运行时构造任意一个类的对象，并且可以在运行时...

			
		

	





	

		

			

				
					
Java反射机制.pptx

				
			

			

				

					08-09
				

			

		

		

			
				
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。在Java中，反射机制主要通过`java.lang.Class`类来实现，提供了访问和操作类、接口、对象等元数据的能力。下面将...

			
		

	





	

		

			

				
					
Java中的反射reflect之getDeclaredMethods和getMethods

				
			

			

				

					xiaoqixiaodong的专栏
				

				

					07-15
					
					619
					
				

			

		

		

			
				
试用Java中的反射reflect之getDeclaredMethods和getMethods




目的：根据类名、方法名以及方法对应的参数，获取方法，并实现方法的调用
1、getDeclaredMethods和getMethods的区别



 Method
getDeclaredMethod(String name, Class... parameterTypes) 

			
		

	





	

		

			

				
					
反射之getDeclaredMethod和getMethod

				
			

			

				

					qq_22583191的博客
				

				

					07-11
					
					1034
					
				

			

		

		

			
				
先看看源码
getMethods：获取当前类和父类的所有public的方法，包括由类或接口声明的对象，以及从超类和接口继承的的方法
	@CallerSensitive
    public Method[] getMethods() throws SecurityException {
        checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
        return copyMethods(privateG

			
		

	





	

		

			

				
					
java反射机制中的getDeclaredField()

				
			

			

				

					weixin_33762321的博客
				

				

					03-25
					
					791
					
				

			

		

		

			
				
为什么80%的码农都做不了架构师？>>> 
                                        
                ...

			
		

	





	

		

			

				
					
java 编程中的反射机制_java反射机制中的getDeclaredField()

				
			

			

				

					weixin_36376765的博客
				

				

					02-27
					
					599
					
				

			

		

		

			
				
反射机制：所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。如下为getDeclaredField()的一个实例：package com.bijian.test;import java.lang.reflect.Field;import java.util.Date;public class Program {public Prog...

			
		

	





	

		

			

				
					
关于java反射的一些基础方法说明--Filed

				
			

			

				

					LLLLLer的博客
				

				

					11-21
					
					360
					
				

			

		

		

			
				
知道一个实体类的字段名称，有获取了这个对象，如何获取它的属性值呢？又如何去设置它的属性值？假如该实体的属性为private属性也可以设置吗

			
		

	





	

		

			

				
					
java 反射 getDeclaredMethod getMethod

				
			

			

				

					weixin_40752987的博客
				

				

					08-04
					
					425
					
				

			

		

		

			
				
Java 反射：深入理解 getDeclaredMethod 和 getMethod
Java 反射是一种强大的工具，它允许程序在运行时探测和使用类及其成员的属性和方法。通过反射，开发者可以动态创建对象、调用方法和访问属性，而无需在编译时确定这些信息。本文将重点介绍 getDeclaredMethod 和 getMetho...

			
		

	





	

		

			

				
					
getDeclaredMethods() 和 getMethods()的区别

				
			

			

				

					qq_51621767的博客
				

				

					04-07
					
					488
					
				

			

		

		

			
				
使用 getDeclaredMethods() 输出的是 Child 类中声明的所有方法，无论访问修饰符如何，但不包括从 Parent 类继承的方法。使用 getMethods() 输出的是 Child 类中所有的公共方法以及从 Parent 类继承下来的公共方法。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值