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.";
}
}