❶ 在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語言的反射機制。主要功能：在運行時判斷任意一個對象所屬的類；在運行時構造任意一個類的對 象；在運行時判斷任意一個類所具有的成員變數和方法；在運行時調用任意一個對象的方法，生成動態代理。
動態執行當前類或其父類的方法，支持私有方法。
具體實現方法如下：
publicstaticvoidmain(String[]args)throwsException{
Classc=Dynamic.class;//得到對象
Method[]methods=c.getDeclaredMethods();//得到方法
for(Methodmethod:methods){
System.out.print(method.getName());//列印參數名Class[]parameterTypes=method.getParameterTypes();
for(inti=0;i<parameterTypes.length;i++){
StringnameString=parameterTypes[i].getName();
System.out.print("parameterType:"+nameString);//列印方法參數類型}
System.out.print("ReturnType:"+method.getReturnType());
System.out.println();
}
Objectobj=c.newInstance();//獲取到方法對象,假設方法的參數是一個int,String,method名為getAge
MethodsAge=c.getMethod("getAge",newClass[]{int.class,String.class});
//獲得參數Object
Object[]arguments=newObject[]{newInteger(23),newString("abc")};
//執行方法
Strings=(String)sAge.invoke(obj,arguments);
System.out.print(s);
}
publicStringgetAge(intage,Stringname){
returnname+":"+age;
}
}
❸ 為什麼用newInstance方法去創建對象是一種利用反射創建對象的方法
首先總結下，創建對象的3中方式：
使用new的方式，最為常見。
使用對象的clone()方法。
使用反射機制的newInstance()方法。
舉個簡單的例子：
packagecom.java;
publicclassDemo
{
/**
*通過兩種方式創建對象，以做對比。
*@paramargs
*@throwsClassNotFoundException
*@throwsInstantiationException
*@throwsIllegalAccessException
*/
publicstaticvoidmain(String[]args)throwsClassNotFoundException,
InstantiationException,IllegalAccessException
{
//我們認為這種方方式，Demo類和Basic類是耦合的，
//編譯Demo類時，Basic類必須存在,拓展性不強。
Basicbasic0=newBasic();
//很明顯這種方式，在編譯Demo類時，並不需要
//Basic類的存在，只要在運行Demo類時，存在即可，
//所以我們認為Demo類和Basic是松耦合的，
//為後期的拓展提供了空間，好處顯而易見。這么說，如果沒有
//反射機制，就沒有struts、spring、hibernate等等這些web框架。
Classclazz=Class.forName("com.java.Basic");
Basicbasic1=(Basic)clazz.newInstance();
}
}
classBasic
{
}
好好體會下，反射帶來的便利。
❹ 關於用java反射調用一個類裡面的方法並執行
Java中要用到反射，首先就必須要獲取到對應的class對象，在Java中有三種方法獲取類對應的class對象。
1、通過類的.class屬性
2、通過類實例的getClass()方法獲取
3、通過Class.forName(String className)方法獲取
現在比如在package下有個類Calculator
publicclassCalculator{
publicdoubleadd(doublescore1,doublescore2){
returnscore1+score2;
}
publicvoidprint(){
System.out.println("OK");
}
publicstaticdoublemul(doublescore1,doublescore2){
returnscore1*score2;
}
}publicclassCalculatorTest{
publicstaticvoidmain(String[]args)throwsException{
//通過類的.class屬性獲取
Class<Calculator>clz=Calculator.class;
//或者通過類的完整路徑獲取,這個方法由於不能確定傳入的路徑是否正確,這個方法會拋ClassNotFoundException
// Class<Calculator>clz=Class.forName("test.Calculator");
//或者new一個實例,然後通過實例的getClass()方法獲取
// Calculators=newCalculator();
// Class<Calculator>clz=s.getClass();
//1.獲取類中帶有方法簽名的mul方法,getMethod第一個參數為方法名,第二個參數為mul的參數類型數組
Methodmethod=clz.getMethod("mul",newClass[]{double.class,double.class});
//invoke方法的第一個參數是被調用的對象,這里是靜態方法故為null,第二個參數為給將被調用的方法傳入的參數
Objectresult=method.invoke(null,newObject[]{2.0,2.5});
//如果方法mul是私有的private方法,按照上面的方法去調用則會產生異常NoSuchMethodException,這時必須改變其訪問屬性
//method.setAccessible(true);//私有的方法通過發射可以修改其訪問許可權
System.out.println(result);//結果為5.0
//2.獲取類中的非靜態方法
Methodmethod_2=clz.getMethod("add",newClass[]{double.class,double.class});
//這是實例方法必須在一個對象上執行
Objectresult_2=method_2.invoke(newCalculator(),newObject[]{2.0,2.5});
System.out.println(result_2);//4.5
//3.獲取沒有方法簽名的方法print
Methodmethod_3=clz.getMethod("print",newClass[]{});
Objectresult_3=method_3.invoke(newCalculator(),null);//result_3為null,該方法不返回結果
}
}
❺ java反射機制詳解
反射就是把Java的各種成分映射成相應的Java類。
Class類的構造方法是private，由JVM創建。
反射是java語言的一個特性，它允程序在運行時（注意不是編譯的時候）來進行自我檢查並且對內部的成員進行操作。例如它允許一個java的類獲取他所有的成員變數和方法並且顯示出來。Java 的這一能力在實際應用中也許用得不是很多，但是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數定義相關的信息。（來自Sun）
JavaBean 是 reflection 的實際應用之一，它能讓一些工具可視化的操作軟體組件。這些工具通過 reflection 動態的載入並取得 Java 組件(類) 的屬性。
反射是從1.2就有的，後面的三大框架都會用到反射機制,涉及到類"Class",無法直接new CLass()，其對象是內存里的一份位元組碼.
Class 類的實例表示正在運行的 Java 應用程序中的類和介面。枚舉是一種類，注釋是一種介面。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共享該 Class 對象。
基本的 Java類型（boolean、byte、char、short、int、long、float 和 double）和關鍵字 void 也表示為 Class 對象。Class 沒有公共構造方法。
Class 對象是在載入類時由 Java 虛擬機以及通過調用類載入器中的 defineClass 方法自動構造的。
Person p1 = new Person();
//下面的這三種方式都可以得到位元組碼
CLass c1 = Date.class();
p1.getClass();
//若存在則載入，否則新建,往往使用第三種,類的名字在寫源程序時不需要知道，到運行時再傳遞過來
Class.forName("java.lang.String");
Class.forName()位元組碼已經載入到java虛擬機中，去得到位元組碼；java虛擬機中還沒有生成位元組碼 用類載入器進行載入，載入的位元組碼緩沖到虛擬機中。
另外，大家可以關注微信公眾號Java技術棧回復：JVM，獲取我整理的系列JVM教程，都是干貨。
考慮下面這個簡單的例子，讓我們看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName("java.util.Stack");
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
}
catch (Throwable e){
System.err.println(e);
}
}
}
public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)
這樣就列出了java.util.Stack 類的各方法名以及它們的限制符和返回類型。這個程序使用 Class.forName 載入指定的類，然後調用 getDeclaredMethods 來獲取這個類中定義了的方法列表。java.lang.reflect.Methods 是用來描述某個類中單個方法的一個類。
以下示例使用 Class 對象來顯示對象的類名：
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
還可以使用一個類字面值（JLS Section 15.8.2）來獲取指定類型（或 void）的 Class 對象。例如：
System.out.println("The name of class Foo is: "+Foo.class.getName());
在沒有對象實例的時候，主要有兩種辦法。
//獲得類類型的兩種方式
Class cls1 = Role.class;
Class cls2 = Class.forName("yui.Role");
注意第二種方式中，forName中的參數一定是完整的類名（包名+類名），並且這個方法需要捕獲異常。現在得到cls1就可以創建一個Role類的實例了，利用Class的newInstance方法相當於調用類的默認的構造器。
Object o = cls1.newInstance();
//創建一個實例
//Object o1 = new Role(); //與上面的方法等價
❻ 如何利用反射創建一個對象List
java中反射的三種方法： 1. 通過Object類的getClass方法來獲取 java.lang.Object中定義有getClass方法：public final Class getClass() 所有Java對象都具備這個方法，該方法用於返回調用該方法的對象的所屬類關聯的Class對象，
❼ java中的反射怎麼用
首先應該說 反射機制提供的功能是很強大的 但是客觀性和維護性很差
一般反射用在 構造框架 以及工具開發等等
但是實際開發軟體運用的並不多
下面是一個簡單的例子
package com.wqx.test4;
public class Test {
public void sayhello(String name)
{
System.out.println("hello:"+name);
}
public static void main(String[] args) {
try {
//把test 這個類載入內存
Class c=Class.forName("com.wqx.test4.Test");
//創建這個類的實例
Object obj=c.newInstance();
//通過class來取得這個方法對象 並且聲明 這個類的參數類型
java.lang.reflect.Method method=c.getMethod("sayhello", Class.forName("java.lang.String"));
//invoke 來執行方法對象 記得參數類型要跟這里的參數匹配
method.invoke(obj, "wqx");
} catch (Exception e) {
// TODO: handle exception
}
}
}
❽ 如何利用java的反射機制動態創建對象
Java反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為Java語言的反射機制。反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。當然反射本身並不是一個新概念，它可能會使我們聯想到光學中的反射概念，盡管計算機科學賦予了反射概念新的含義，但是，從現象上來說，它們確實有某些相通之處，這些有助於我們的理解。
Java反射機制主要提供下面幾種用途：
在運行時判斷任意一個對象所屬的類
在運行時構造任意一個類的對象
在運行時判斷任意一個類所具有的成員變數和方法
在運行時調用任意一個對象的方法
以下，我們就以動態創建對象為例，通過代碼來解釋一下反射：
public class ReflectionTest {
public static void main(String[] args) throws Exception {
// 建立學生對象
Student student = new Student();
// 為學生對象賦值
student.setStuName("Wanggc");
student.setStuAge(24);
// 建立拷貝目標對象
Student destStudent = (Student) Bean(student);
// 輸出拷貝結果
System.out.println(destStudent.getStuName() + ":"
+ destStudent.getStuAge());
}
/**
* 拷貝學生對象信息。
*
* @param from
拷貝源對象
* @param dest
拷貝目標對象
* @throws Exception
例外
*/
private static Object Bean(Object from) throws Exception {
// 取得拷貝源對象的Class對象
Class<?> fromClass = from.getClass();
// 取得拷貝源對象的屬性列表
Field[] fromFields = fromClass.getDeclaredFields();
// 取得拷貝目標對象的Class對象
Object ints = fromClass.newInstance();
for (Field fromField : fromFields) {
// 設置屬性的可訪問性
fromField.setAccessible(true);
// 將拷貝源對象的屬性的值賦給拷貝目標對象相應的屬性
fromField.set(ints, fromField.get(from));
}
return ints;
}
}
❾ mybatis的反射工具類—MetaObject（反射對象類）
MeatObject是Mybatis的工具類，通過MetaObject獲取和設置對象的屬性值。
返回結果：
基本的pojo對象：
MetaObject提供了一個工具類：
當調用 SystemMetaObject 獲取 MetaObject 對象時，每次均 new DefaultReflectorFactory() 了一個反射工廠類。
繼續查看：
這個類並沒有做很復雜的操作，就是獲取object的type類型，且存儲到Map中。當同一個object調用 forObject() 時，後續調用可以在緩存中獲取反射對象。
但注意： SystemMetaObject 方法因為每次均new了一個新的 DefaultReflectorFactory 工廠。若每次在方法中調用 SystemMetaObject.forObject 獲取 MetaObject 對象。同一個對象可能不會走緩存。
推薦做法： 將 DefaultReflectorFactory 聲明為靜態變數：
在創建 MetaObject 對象的時候，就會將傳入的Object對象的所有反射對象都緩存起來。後續調用 metaObject.setValue 等方法時，直接在緩存中獲取到反射對象，然後執行反射操作。
創建MetaObject對象時，選擇不同的Wrapper進行包裝。
以普通的pojo為例，創建 BeanWrapper 對象，在 forClass 方法中會遍歷object的所有方法。獲取反射對象。
到此處：
到達此處，判斷 緩存 中是否存在某對象的解析結果：
注意： MetaObject.forObject 會將object結果緩存起來，後續在使用MetaObject.forObject創建對象時，直接在緩存中獲取。
若沒有存在，則調用 new Reflector(type); 去創建cache對象。
總方法：
2. 刪除方法的前綴，獲取屬性名：
3. key為屬性名，value是集合：
4. 將局部變數放入到屬性集合中：
5. 放入到屬性變數中
設置分詞器：
https://www.cnblogs.com/javadeveloper/archive/2004/01/13/13151682.html
❿ 如何通過反射來創建對象
Class clazz = Class.forName("com.fanshe.Person");
//當然如果你需要將全部的欄位都訪問的話，那麼就需要getdecaredFields()方法
Field field = clazz.getDeclaredField("age");//該方法會調用該類中所有的欄位
field.setAccessible(true);//暴力訪問，取消age的私有許可權。讓對象可以訪問
Object obj = clazz.newInstance();
field.set(obj, 32);//設置對象中，私有變數的值
int age = field.getInt(obj);//獲取該欄位的值，必須與對象結合起來，不然的話，會出現錯誤