1. java里面，反射父类里面数字类型字段，怎么set值
你在invoke反射方法时。这个你要调用父类的构造方法或者set方法来赋值。就可以的。
2. Java反射的几个方法区别
1. 通过Object类的getClass方法来获取
java.lang.Object中定义有getClass方法：public final Class getClass()
所有Java对象都具备这个方法，该方法用于返回调用该方法的对象的所属类关联的Class对象，例如：
Date date1 = new Date();
Date date2 = new Date();
Class c1 = date1.getClass();
Class c2 = date2.getClass();
System.out.println(c1.getName());
// java.util.Date
System.out.println(c1 == c2);
// true
上面的代码中，调用Date对象date1的getClass方法将返回用于封装Date类信息的Class对象。
这里调用了Class类的getName方法：public String getName()，这个方法的含义很直观，即返回所封装的类的名称。
需要注意的是，代码中的date1和date2的getClass方法返回了相同的Class对象（c1==c2的值为true）。这是因为，对于相同的类，JVM只会载入一次，而与该类对应的Class对象也只会存在一个，无论该类实例化了多少对象。
另外，需要强调的是，当一个对象被其父类的引用或其实现的接口类型的引用所指向时，getClass方法返回的是与对象实际所属类关联的Class对象。例如：
List list = new ArrayList();
System.out.println(list.getClass().getName()); // java.util.ArrayList
上面的代码中，语句list.getClass()方法返回的是list所指向对象实际所属类java.util.ArrayList对应的 Class对象而并未java.util.List所对应的Class对象。有些时候可以通过这个方法了解一个对象的运行时类型，例如：
HashSet set = new HashSet();
Iterator it = set.iterator();
System.out.println(it.getClass().getName()); //java.util.HashMap$KeyIterator
从代码可以看出，HashSet的iterator方法返回的是实现了Iterator接口的HashMap内部类（KeyIterator）对象。
因为抽象类和接口不可能实例化对象，因此不能通过Object的getClass方法获得与抽象类和接口关联的Class对象。
2. 使用.class的方式
使用类名加“.class”的方式即会返回与该类对应的Class对象。例如：
Class clazz = String.class;
System.out.println(clazz.getName()); // java.lang.String
这个方法可以直接获得与指定类关联的Class对象，而并不需要有该类的对象存在。
3. 使用Class.forName方法
Class有一个着名的static方法forName：public static Class forName(String className) throws ClassNotFoundException
该方法可以根据字符串参数所指定的类名获取与该类关联的Class对象。如果该类还没有被装入，该方法会将该类装入JVM。
该方法声明抛出ClassNotFoundException异常。顾名思义，当该方法无法获取需要装入的类时（例如，在当前类路径中不存在这个类），就会抛出这个异常。
3. 说说对java反射的理解，使用反射如何获取一个类的所有方法，使用反射需要注意哪些问题
反射说白了就是可以获得一个类的所有信息，主要包括方法和属性两部分。
1.获得方法包括获得方法的名称，方法的返回类型，方法的访问修饰符，以及通过反射执行这个方法。
2.获得属性包括属性的名称，类型，访问修饰符，以及这个属性的值。
这些获得都有相应的API提供操作。
举个例子：
先定义一个类，有age这个属性，以及age的get和set方法：
public class TestRflectionFather {
public int age =32;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
然后操作获得所有方法：
import java.lang.reflect.Method;
public class Testmain {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("TestRflectionFather");
Method[] methods =clazz.getDeclaredMethods();
for(Method me:methods)
{
System.out.println(me.getName());
}
}
}
//最后输出
getAge
setAge
4. java中的反射机制是什么，有什么作用啊
Method类中的方法的使用（含代码和注释）：
getMethods()获得本类及父类中的public权限修饰**符方法
getDeclaredMethods()专门获得调用该方法的对象的本类中的所有方法包括private权限修饰符**的方法
getDeclaredMethod(Stringname,class<?>...parameterTypes)
第一个参数：方法的名称
第二个参数：可变长度，写你要查找的那个方法的参数类型列表.class
getParameterCount()得到方法的参数个数123456
packageLessonForReflection03;importjava.lang.reflect.Method;importjava.lang.reflect.Modifier;abstractclassCard{
privatevoidcreatRandomNumbers(intcount)//private关键字
{
}
publicvoidgetFullCardsNumbers(String[]random,Stringpre_numbers)
{
}
publicstaticvoidgetUserInfor()
{
}
(Stringtel);
(intsal1,intsal2),ArithmeticException;}publicclassMethodInforGetter{
publicstaticvoidmain(String[]args)
{
Class<?>c1=Card.class;
System.out.println("-------------------------");
Method[]m1=c1.getMethods();//getMethods()获得本类及父类中的public方法！
for(Methodm:m1)
{
System.out.println(m);
}
System.out.println("-------------------------");
Method[]m2=c1.getDeclaredMethods();//getDeclaredMethods()专门获得本类中的所有方法包括private！
for(Methodm:m2)
{
System.out.println(m);
}
System.out.println("-------------------------");
/*
*getDeclaredMethod(Stringname,class<?>...parameterTypes)
*第一个参数：方法的名称
*第二个参数：可变长度，写你要查找的那个方法的参数类型列表
*
*getParameterCount()得到方法的参数个数
*/
try
{
Methodm3=c1.getDeclaredMethod("getUserInfor");
System.out.println(m3);
//getParameterCount()方法,获得方法参数个数
System.out.println(m3.getParameterCount());
System.out.println(Modifier.toString(m3.getModifiers()));//获得方法修饰符
System.out.println(m3.getReturnType());
System.out.println("-------------------------");
Methodm4=c1.getDeclaredMethod("getUserInfor",int.class,int.class);
//getExceptionTypes()可以获得初始化当前Method对象的给Class对象初始化的那个类的那个指定方法抛出的异常类型
Class<?>[]exception=m4.getExceptionTypes();
for(Class<?>e:exception)
{
System.out.println(e);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}576777879808182838485868788
Constructor类中的方法的使用www.xiaoyuani.com（含代码和注释）：
java.lang.reflect.Constructor:
Constructor[]getConstructor()获得本类里的public权限修饰符构造函数，不能获取父类的！
Constructor[]getDeclaredConstructor()获得本类中的所以构造函数！
Constructor<T>getConstructor(Class...parameterType)用参数决定获得本类中的某个的构造方法,只能获得public的
Constructor<T>getDeclaredConstructor(Class...parameterType)用参数决定获得本类中的某个构造方法
附：
JDK8.0之后新增的类：
Executable：
它是Method和Constructor的父类
常用方法：
getParameter()获得类中方法参数
getExceptionTypes()获得类中某个方法抛出异常类型
getMoidfiers()获得方法权限修饰符
Parameter:
封装并代表了参数实例123456789101112131415
packageLessonForReflection03;importjava.lang.reflect.Constructor;importjava.lang.reflect.Modifier;importjava.lang.reflect.Parameter;/*
*java.lang.reflect.Constructor
*
*Constructor[]getConstructor();获得本类里的public权限修饰符构造函数，不能获取父类的
*Constructor[]getDeclaredConstructor();得本类里的全部构造
*
*Constructor<T>getConstructor(Class...parameterType);用参数决定获得哪个构造方法
*Constructor<T>getDeclaredConstructor(Class...parameterType);
*
*/{
publicstaticvoidmain(String[]args)
{
System.out.println("获得Cricle本类里的public权限修饰符构造函数，不能获取父类的Constructor[]getConstructor()");
System.out.println("子类继承不了父类中的构造方法和private");
//Constructor[]getConstructor()获得Cricle本类里的public权限修饰符构造函数，不能获取父类的
//子类继承不了父类中的构造方法和private
Class<Circle>c1=Circle.class;
Constructor<?>[]cons1=c1.getConstructors();
for(Constructor<?>cons:cons1)
{
System.out.println(cons);
//System.out.println(cons.getName());
}
System.out.println("-----------------------");
System.out.println("方法获得本类中的所有构造函数getDeclaredConstructor()");
Constructor<?>[]cons2=c1.getDeclaredConstructors();
for(Constructor<?>cons:cons2)
{
System.out.println(cons);
}
System.out.println("-----------------------");
try
{
System.out.println("方法用参数指定获得本类！构造方法,只能获取public的Constructor<T>getConstructor(Class...parameterType)");
Constructor<?>cons3=c1.getConstructor(int.class);
System.out.println(Modifier.toString(cons3.getModifiers()));
System.out.println(cons3);
System.out.println("-----------------------");
System.out.println("方法用参数指定获得本类！构造方法任何权限修饰符的都可以获得Constructor<T>getDeclaredConstructor(Class...parameterType)");
Constructor<?>cons4=c1.getDeclaredConstructor(String.class);
System.out.println(cons4);
System.out.println("-----------------------");
/*
*JDK8.0之后新增的类
*Executable：
*是Method和Constructor的父类
*方法：
*getParameter();
*getExceptionTypes();
*getModifiers();
*getTypeParameters();
*
*Parameter:
*封装并代表了参数实例
*/
System.out.println("获取类中方法的参数getParameters()");
Constructor<?>cons5=c1.getDeclaredConstructor(int.class,String.class);
Parameter[]p1=cons5.getParameters();
for(Parameterp:p1)
{
System.out.println(p);
}
}catch(NoSuchMethodException|SecurityExceptione)
{
e.printStackTrace();
}
}}5767778798081828384858687
代码中提到的Circle类和Shape类二者为继承关系：
packageLessonForReflection03;publicclassCircleextendsShape{
privateintr;
privateStringcolor;
publicCircle(intr,Stringcolor)
{
super();
this.r=r;
this.color=color;
}
publicCircle(intr)
{
super();
this.r=r;
}
protectedCircle(Stringcolor)
{
super();
this.color=color;
}
Circle()
{
super();
}}
packageLessonForReflection03;publicclassShape{
privateintper;
publicShape(intper)
{
super();
this.per=per;
}
publicShape()
{
super();
}}1234567891011121314151617
部分文字来源于：
咕嘟咖啡杨海滨老师 — 《java编程语言高级特性》
轻量化研习Java相关技术倡导者
“爱码学院”联合创始人自适应教学理念提出者践行者；多年开发及项目管理经历；出版《JavaEE企业级应用与开发》一书；10余年高校项目实践毕设指导经验；企业软培经验丰富
5. java中的反射机制是什么有什么作用呢求解，谢谢。
1. 反射机制是什么
反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
2. 反射机制能做什么
反射机制主要提供了以下功能：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。
3. 反射机制的相关API
通过一个对象获得完整的包名和类名
packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
TestReflecttestReflect=newTestReflect();
System.out.println(testReflect.getClass().getName());
//结果net.xsoftlab.ke.TestReflect
}
}
实例化Class类对象
packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
Class<?>class2=null;
Class<?>class3=null;
//一般采用这种形式
class1=Class.forName("net.xsoftlab.ke.TestReflect");
class2=newTestReflect().getClass();
class3=TestReflect.class;
System.out.println("类名称"+class1.getName());
System.out.println("类名称"+class2.getName());
System.out.println("类名称"+class3.getName());
}
}
获取一个对象的父类与实现的接口
packagenet.xsoftlab.ke;
importjava.io.Serializable;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//取得父类
Class<?>parentClass=clazz.getSuperclass();
System.out.println("clazz的父类为："+parentClass.getName());
//clazz的父类为：java.lang.Object
//获取所有的接口
Class<?>intes[]=clazz.getInterfaces();
System.out.println("clazz实现的接口有：");
for(inti=0;i<intes.length;i++){
System.out.println((i+1)+"："+intes[i].getName());
}
//clazz实现的接口有：
//1：java.io.Serializable
}
}
获取某个类中的全部构造函数 - 详见下例
通过反射机制实例化一个类的对象
packagenet.xsoftlab.ke;
importjava.lang.reflect.Constructor;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
class1=Class.forName("net.xsoftlab.ke.User");
//第一种方法，实例化默认构造方法，调用set赋值
Useruser=(User)class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
//第二种方法取得全部的构造函数使用构造函数赋值
Constructor<?>cons[]=class1.getConstructors();
//查看每个构造方法需要的参数
for(inti=0;i<cons.length;i++){
Class<?>clazzs[]=cons[i].getParameterTypes();
System.out.print("cons["+i+"](");
for(intj=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//结果
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user=(User)cons[0].newInstance("Rollen");
System.out.println(user);
//结果User[age=0,name=Rollen]
user=(User)cons[1].newInstance(20,"Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
}
}
classUser{
privateintage;
privateStringname;
publicUser(){
super();
}
publicUser(Stringname){
super();
this.name=name;
}
publicUser(intage,Stringname){
super();
this.age=age;
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"User[age="+age+",name="+name+"]";
}
}
获取某个类的全部属性
packagenet.xsoftlab.ke;
importjava.io.Serializable;
importjava.lang.reflect.Field;
importjava.lang.reflect.Modifier;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
System.out.println("===============本类属性===============");
//取得本类的全部属性
Field[]field=clazz.getDeclaredFields();
for(inti=0;i<field.length;i++){
//权限修饰符
intmo=field[i].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=field[i].getType();
System.out.println(priv+""+type.getName()+""+field[i].getName()+";");
}
System.out.println("==========实现的接口或者父类的属性==========");
//取得实现的接口或者父类的属性
Field[]filed1=clazz.getFields();
for(intj=0;j<filed1.length;j++){
//权限修饰符
intmo=filed1[j].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=filed1[j].getType();
System.out.println(priv+""+type.getName()+""+filed1[j].getName()+";");
}
}
}
通过反射机制调用某个类的方法
packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//调用TestReflect类中的reflect1方法
Methodmethod=clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
//Java反射机制-调用某个类的方法1.
//调用TestReflect的reflect2方法
method=clazz.getMethod("reflect2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"张三");
//Java反射机制-调用某个类的方法2.
//age->20.name->张三
}
publicvoidreflect1(){
System.out.println("Java反射机制-调用某个类的方法1.");
}
publicvoidreflect2(intage,Stringname){
System.out.println("Java反射机制-调用某个类的方法2.");
System.out.println("age->"+age+".name->"+name);
}
}
通过反射机制操作某个类的属性
packagenet.xsoftlab.ke;
importjava.lang.reflect.Field;
publicclassTestReflect{
privateStringproprety=null;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
Objectobj=clazz.newInstance();
//可以直接对private的属性赋值
Fieldfield=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"Java反射机制");
System.out.println(field.get(obj));
}
}
4. 反射机制的应用实例
在泛型为Integer的ArrayList中存放一个String类型的对象。
packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
ArrayList<Integer>list=newArrayList<Integer>();
Methodmethod=list.getClass().getMethod("add",Object.class);
method.invoke(list,"Java反射机制实例。");
System.out.println(list.get(0));
}
}
通过反射取得并修改数组的信息
packagenet.xsoftlab.ke;
importjava.lang.reflect.Array;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
int[]temp={1,2,3,4,5};
Class<?>demo=temp.getClass().getComponentType();
System.out.println("数组类型："+demo.getName());
System.out.println("数组长度"+Array.getLength(temp));
System.out.println("数组的第一个元素:"+Array.get(temp,0));
Array.set(temp,0,100);
System.out.println("修改之后数组第一个元素为："+Array.get(temp,0));
}
}
将反射机制应用于工厂模式
packagenet.xsoftlab.ke;
interfacefruit{
publicabstractvoideat();
}
classAppleimplementsfruit{
publicvoideat(){
System.out.println("Apple");
}
}
classOrangeimplementsfruit{
publicvoideat(){
System.out.println("Orange");
}
}
classFactory{
publicstaticfruitgetInstance(StringClassName){
fruitf=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch(Exceptione){
e.printStackTrace();
}
returnf;
}
}
/**
*对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。当我们添加很多的子类的时候，会很麻烦。
*Java工厂模式可以参考
*http://ke.xsoftlab.net/view/java-factory-pattern
*
*现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
*
*但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
*
*java读取properties配置文件的方法可以参考
*http://ke.xsoftlab.net/view/java-read-the-properties-configuration-file
*
*@authorxsoftlab.net
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
fruitf=Factory.getInstance("net.xsoftlab.ke.Apple");
if(f!=null){
f.eat();
}
}
}
我有一个微信公众号，经常会分享一些Java技术相关的干货，还有一些学习资源。
如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。
6. 如何用反射机制访问继承自私有类的方法,最好用java 实现。
明白你的意思了，Method是属于类的，不是属于对象的，意思就是这个对象可以访问这个方法，实际是访问的父类的方法，本身是没有的，所以，你得通过他的父类去查这个方法，给你个曾经用过的反射例子，你可以参考下:
/**
* 反射获得方法，若本类不存在该方法则递归调用父类查找，若方法始终不存在返回空
* @author lzxz
* @param clazz 类对象
* @param methodName 方法名
* @param parameterTypes 方法参数列表
* @return 此方法获得Method对象总是可用的
*/
public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
Method method = null;
try {
if(clazz == null) return null;
method = clazz.getDeclaredMethod(methodName, parameterTypes);
method.setAccessible(true);
return method;
} catch (NoSuchMethodException e) {
return getMethod(clazz.getSuperclass(), methodName, parameterTypes);
}
}
7. JAVA中重写父类方法后，这个方法如何调用父类私有属性方法
父类的私有属性和方法是不被子类继承调用的，如果你非要这么做可以
1、在父类中另外定义protected
的方法操作私有方法，子类调用该方法
2、将私有方法改为protected
3、使用反射，获取父类所有方法，根据名称调用
8. JAVA中重写父类方法后，这个方法如何调用父类私有属性方法
父类的私有属性和方法是不被子类继承调用的，如果你非要这么做可以
1、在父类中另外定义protected 的方法操作私有方法，子类调用该方法
2、将私有方法改为protected
3、使用反射，获取父类所有方法，根据名称调用
9. 求教Java里面如何反射invoke父类的overriden方法
import java.lang.reflect.Method;
public class InvokeTest {
public static void main(String[] args) {
Class<?> clazz;
Object obj;
try {
InvokeTest it = new InvokeTest();
clazz = Class.forName("com.test.invoke.User");
obj = clazz.newInstance();
Param p = new Param();
p.setMethodName("introction");
p.setParamTypes(new Class<?>[]{String.class,int.class});
p.setParamValuese(new Object[]{"Tom",20});
Object result = it.call(obj, p);
System.out.println(result+"");
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 反射方法调用
* @param declareCLass classInstatnce
* @param param 参数设置类
* @return
* @throws Exception
*/
public Object call(Object declareCLass, Param param) throws Exception {
Class<?> clazz = declareCLass.getClass(); //获取class对象
String name = param.getMethodName(); //从param类中获取调用方法名
Class<?>[] methodParamTypes = param.getParamTypes(); //从param类中获取调用方法参数类型
Object[] objs = param.getParamValuese(); //从param类中获取调用方法参数值
Method method = clazz.getDeclaredMethod(name, methodParamTypes); //通过class对象获取对应的方法
return method.invoke(declareCLass, objs); //invoke调用方法，传入 classInstance、 参数值
}
}
/**
* 参数设置类
* @author Administrator
*
*/
class Param {
private String methodName;
private Class<?>[] paramTypes;
private Object[] paramValuese;
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public Class<?>[] getParamTypes() {
return paramTypes;
}
public void setParamTypes(Class<?>[] paramTypes) {
this.paramTypes = paramTypes;
}
public Object[] getParamValuese() {
return paramValuese;
}
public void setParamValuese(Object[] paramValuese) {
this.paramValuese = paramValuese;
}
}
class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
System.out.println("called method setName value = " + name);
}
public int getAge() {
return age;
}
public void setAge(int age) {
System.out.println("called method setAge value = " + age);
this.age = age;
}
public String introction(String name,int age){
return "My name is "+name+". I'm "+age+" years old.";
}
}