『壹』 在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]]