『壹』 在java中，怎么利用反射获取一个方法
java的反射用法：(异常请自行处理)
①找到类：Class cl = Class.forName("java.util.Date");
②创建对象(要求这个类中含有空参数的构造方法)：Object obj = cl.newInstence();
③根据名称和参数找方法：Method method1 = cl.getMethod("getTime");//如果没有参数不用写第二个参数如果有参数的如：Method method2 = cl.getMethod("setTime",long.class);
④在某个对象上面执行方法，Object result = method1.invoke(obj);//如果有参数的Object result = method2.invoke(obj,21317362721);
执行的方如果有返回值，将返回值返回，否则返回null
『贰』 java中反射的三种方法是
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异常。顾名思义，当该方法无法获取需要装入的类时（例如，在当前类路径中不存在这个类），就会抛出这个异常。
例如，如果当前类路径中存在Foo类：
package org.whatisjava.reflect;
public class Foo {
public Foo() {
System.out.println("Foo()");
}
static {
System.out.println("Foo is initialized");
}
}
运行下面的代码：
Class clazz = Class.forName("org.whatisjava.reflect.Foo");
控制台会有如下输出：
Foo is initialized
Class.forName("org.whatisjava.reflect.Foo")首先会将reflection.Foo类装入JVM，并返回与之关联的Class对象。JVM装入Foo类后对其进行初始化，调用了其static块中的代码。需要注意的是：forName方法的参数是类的完 整限定名（即包含包名）。
区别于前面两种获取Class对象的方法：使用Class.forName方法所要获取的与之对应的Class对象的类可以通过字符串的方式给定。该方法通常用于在程序运行时根据类名动态的载入该类并获得与之对应的Class对象。
通过上面的文章相信你对java的反射机制有了一定的认识,同时也对java中Class类的用法有了比较清晰的理解,在我们实际工作的过程中,我们不断的运用java知识来解决实际生活中的问题的时候我们就能对java反射机制有一个更深入的理解!
二、代码示例
1.ClassTest.java
[java] view plain
/**
* java中Class类的使用
*/
import java.io.*;
import java.lang.reflect.*;
public class ClassTest1 {
public ClassTest1(){
}
public static void main(String[] args) throws Exception{
ClassTest1 test=new ClassTest1();
ClassTest1 test1=test.getClass().newInstance();
//test1=test;
test.printMessage();
test1.printMessage();
System.out.println(test.hashCode());
System.out.println(test1.hashCode());
Method[] method=test1.getClass().getMethods();
for(Method m :method){
System.out.println(m.getDeclaringClass());
System.out.println(m.getName());
}
}
public void printMessage(){
System.out.println("Created successful!");
}
}
运行结果：
[plain] view plain
Created successful!
Created successful!
14576877
12677476
class ClassTest1
printMessage
class ClassTest1
main
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
wait
class java.lang.Object
hashCode
class java.lang.Object
getClass
class java.lang.Object
equals
class java.lang.Object
toString
class java.lang.Object
notify
class java.lang.Object
notifyAll
2.TestClass.java
[java] view plain
/**
*
*/
public class TestClass {
public static void main(String[] args)
{
try {
// 测试Class.forName()
Class testTypeForName = Class.forName("TestClassType");
System.out.println("testForName---" + testTypeForName);
// 测试类名.class
Class testTypeClass = TestClassType.class;
System.out.println("testTypeClass---" + testTypeClass);
// 测试Object.getClass()
TestClassType testGetClass = new TestClassType();
System.out.println("testGetClass---" + testGetClass.getClass());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class TestClassType {
// 构造函数
public TestClassType() {
System.out.println("----构造函数---");
}
// 静态的参数初始化
static {
System.out.println("---静态的参数初始化---");
}
// 非静态的参数初始化
{
System.out.println("----非静态的参数初始化---");
}
}
运行结果:
[plain] view plain
---静态的参数初始化---
testForName---class TestClassType
testTypeClass---class TestClassType
----非静态的参数初始化---
----构造函数---
testGetClass---class TestClassType
分析：根据结果可以发现，三种生成的Class对象一样的，并且三种生成Class对象只打印一次“静态的参数初始化”。
『叁』 java反射获取方法不定参数的名称和类型
(Object...objects){
for(Objectobj:objects){
Classclz=obj.getClass();
System.out.println(clz);
}
returnfalse;
}
『肆』 java反射中是否可以获取到方法的参数名称
不能去参数名称 可以去参数类型
method.getParameterTypes()
『伍』 用java的反射机制怎么获取一个类中里面方法中局部变量
publicclassPerson{
privateStringname;
privateintage;
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicstaticvoidmain(String[]args){
try{
Classc=Class.forName(Person.class.getName());
//获取类的属性
Field[]fields=c.getDeclaredFields();
for(inti=0;i<fields.length;i++){
System.out.println("类的属性有："+Modifier.toString(fields[i].getModifiers())+""+fields[i].getType()+""+fields[i].getName());
}
//获取类的方法
Method[]methods=c.getMethods();
for(intj=0;j<methods.length;j++){
System.out.println("类的方法有："+Modifier.toString(methods[j].getModifiers())+""+methods[j].getReturnType()+""+methods[j].getName());
}
}catch(ClassNotFoundExceptione){
e.printStackTrace();
}
}
}
//运行结果如下：
类的属性有：privateclassjava.lang.Stringname
类的属性有：privateintage
类的方法有：publicstaticvoidmain
类的方法有：publicclassjava.lang.StringgetName
类的方法有：publicvoidsetName
类的方法有：publicvoidsetAge
类的方法有：publicintgetAge
类的方法有：publicfinalvoidwait
类的方法有：publicfinalvoidwait
类的方法有：publicfinalnativevoidwait
类的方法有：publicbooleanequals
类的方法有：publicclassjava.lang.StringtoString
类的方法有：publicnativeinthashCode
类的方法有：publicfinalnativeclassjava.lang.ClassgetClass
类的方法有：publicfinalnativevoidnotify
类的方法有：
『陆』 Java反射机制获取set()方法 并且为set()方法传值
Class.getDeclaredMethod()
是获取这个类中所有的方法，返回的是Method[]
如果有参数，第1个是方法名称，第2个是该方法的所有参数数组，这样返回的是Method这个对象
Method.invoke()
传入调用方法的类，另一个是调用这个方法所需要的参数，如果该方法没有参数，可以不填写，在JDK1,4之前，第2个参数是传入一个数组的，但是在jdk1.5之后，可以不传数组，多个参数用逗号隔开
不知道你听明白没
『柒』 java怎么通过反射的方式调用可变形参的方法
ava反射调用可变参数的方法的方式是传入objects参数，如下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Reflect {
public static void main(String[] args) throws Exception {
Class<?> clazz = Single.class;
Single single = (Single) clazz.newInstance();
List<String> list = new ArrayList<String>(){
private static final long serialVersionUID = 1L;
{
add("fuck");
add("ni");
add("mei");
}
};
//获取method两种方式， 在method中 数组的的空间大小是可以随便写的不一定使用0
/* 1 */
Method method = clazz.getDeclaredMethod("method", Array.newInstance(Object.class, 0).getClass());
/* 2 */
method = clazz.getDeclaredMethod("method", (new Object[0]).getClass());
//初始化参数
『捌』 在JAVA中，怎么利用反射获取一个方法
java中利用反射获取方法：
1.先找到方法所在类的字节码
2.找到需要被获取的方法
Class类中获取方法：
public Method[] getMethods();获取包括自身和继承（实现）过来的所有的public方法——Method不支持泛型<>，即后面不接<>
public Method[] getDeclaredMethods();获取自身所有的方法(private、public、protected，和访问权限无关)，不包括继承的
public Method[] getMethod(String methodName, Class<T>...parameterTypes);表示获取指定的一个公共的方法，包括继承的
参数： methodName：表示获取的方法的名字
parameterTypes：表示获取的方法的参数的Class类型
public Method[] getDeclaredMethod(String methodName, Class<T>...parameterTypes);//表示获取本类中的一个指定的方法（private、protected、public，与访问权限无关），不包括继承的方法。
参数:methodName: 表示被调用方法的名字
parameterTypes:表示被调用方法的参数的Class类型如String.class只有通过方法签名才能找到唯一的方法，方法签名=方法名+参数列表（参数类型、参数个数、参数顺序）。
public Method getDeclaredMethod(String name,Class... parameterTypes):表示调用指定的一个本类中的方法(不包括继承的)
参数: methodName: 表示被调用方法的名字
parameterTypes:表示被调用方法的参数的Class类型如String.class
举例：
classP{
publicvoidt1(){}
voidt2(){}
privatevoidt3(){}
}
classPeopleextendsP{
publicvoidsayHi(){
System.out.println("sayHi()");
}
publicvoidsayHello(Stringname){
System.out.println("sayHello(Stringname)"+"name="+name);
}
privatevoidsayGoodBye(Stringname,intage){
System.out.println("sayGoodBye(Stringname,intage)"+"name="+name+"age="+age);
}
}
publicclassMethodDemo{
publicstaticvoidmain(String[]args)throwsException{
Classclazz=People.class;
//获取类自身及父类所有public方法
Methodms[]=clazz.getMethods();
for(Methodm:ms){
System.out.println(m);
}
System.out.println("---------------------------");
//获取类自身所有方法(不会获取父类方法)
ms=clazz.getDeclaredMethods();
for(Methodm:ms){
System.out.println(m);
}
System.out.println("---------------------------");
//只能获取父类中的public方法，无法获取到父类的默认权限和private权限方法
Methodm=clazz.getMethod("t1",null);//publicvoidcom.reflex.P.t1()
System.out.println(m);
m=clazz.getMethod("sayHello",String.class);
System.out.println(m);
//Exceptioninthread"main"java.lang.NoSuchMethodException:com.reflex.People.sayGoodBye(java.lang.String,int)
//getMethod方法只能获取public的
//m=clazz.getMethod("sayGoodBye",String.class,int.class);
//System.out.println(m);
m=clazz.getDeclaredMethod("sayGoodBye",String.class,int.class);
System.out.println(m);
//带Declared的无法获取父类中的方法
//m=clazz.getDeclaredMethod("t1",null);//Exceptioninthread"main"java.lang.NoSuchMethodException:com.reflex.People.t1()
//System.out.println(m);
}
}
『玖』 java 反射 如何得到构造函数的参数列表
public class refP{
public static void main(String[] args)
{
Class userClass=String.class;//将此处换成你的class 就成了
//---- 获取所有构造方法
Constructor[] cons=userClass.getDeclaredConstructors();
System.out.println("类User的构造方法包括: ");
//---- 打印出构造方法的前缀
for (int i=0;i<cons.length;i++)
{
Constructor con=cons[i]; //取出第i个构造方法。
System.out.print(Modifier.toString(con.getModifiers()));
//---- 打印该构造方法的前缀修饰符
System.out.print(" "+con.getName()+"("); //打印该构造方法的名字
//---- 打印该构造方法的参数。
Class[] parameterTypes=con.getParameterTypes(); //构造方法参数集但是 数组类型显示特殊
for(int j=0;j<parameterTypes.length;j++)
{
System.out.print(parameterTypes[j].getName());
}
System.out.println(")");
}
}
}
/*核心语句：
Class userClass=String.class;//找到对应的class类
Constructor[] cons=userClass.getDeclaredConstructors();//找到对应的构造器数组
Class[] parameterTypes=con.getParameterTypes(); //找到每个构造器对应的参数类型数组
『拾』 如何通过java 反射 调用一个 含有 可变参数的 方法呢
java反射调用可变参数的方法的方式是传入objects参数，如下代码：
publicclassReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Single.class;
Singlesingle=(Single)clazz.newInstance();
List<String>list=newArrayList<String>(){
=1L;
{
add("fuck");
add("ni");
add("mei");
}
};
//获取method两种方式，在method中数组的的空间大小是可以随便写的不一定使用0
/*1*/
Methodmethod=clazz.getDeclaredMethod("method",Array.newInstance(Object.class,0).getClass());
/*2*/
method=clazz.getDeclaredMethod("method",(newObject[0]).getClass());//初始化参数
/*1*/
Objectobjs=Array.newInstance(Object.class,2);
Array.set(objs,0,list);
Array.set(objs,1,"23");
method.invoke(single,objs);
/*2*/
Object[]objects={1,"fuck",list};
method.invoke(single,newObject[]{objects});
}
}
classSingle{
publicvoidmethod(Object...objs){
System.out.println(Arrays.deepToString(objs));
}
}
结果:
[[fuck,ni,mei],23]
[1,fuck,[fuck,ni,mei]]