java反射父類的屬性值

① 怎樣用java反射機制獲得父類private 屬性的值

Class c = null;
try {
c = Class.forName("com.ibm.lan.test.Sub");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

Class superClass = c.getSuperclass();
Field[] fields = superClass.getDeclaredFields();

這是得到父類的屬性
for(int i=0;i<fields .length;i++)
{
fields [i].setAccessible(true);
System.out.println(fields [i].getType());
fields [i].set();
}

② JAVA反射機製作用

一、什麼是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。這一概念的提出很快引發了計算機科學領域關於應用反射性的研究。它首先被程序語言的設計領域所採用,並在Lisp和面向對象方面取得了成績。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基於反射機制的語言。最近，反射機制也被應用到了視窗系統、操作系統和文件系統中。反射本身並不是一個新概念，盡管計算機科學賦予了反射概念新的含義。在計算機科學領域，反射是指一類應用，它們能夠自描述和自控制。也就是說，這類應用通過採用某種機制來實現對自己行為的描述（self-representation）和監測（examination），並能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。二、什麼是Java中的類反射：
Reflection 是 Java 程序開發語言的特徵之一，它允許運行中的 Java 程序對自身進行檢查，或者說「自審」，並能直接操作程序的內部屬性和方法。Java 的這一能力在實際應用中用得不是很多，但是在其它的程序設計語言中根本就不存在這一特性。例如，Pascal、C 或者 C++ 中就沒有辦法在程序中獲得函數定義相關的信息。
Reflection 是 Java 被視為動態（或准動態）語言的關鍵，允許程序於執行期 Reflection APIs 取得任何已知名稱之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可於執行期生成instances、變更 fields 內容或喚起 methods。三、Java類反射中所必須的類：
Java的類反射所需要的類並不多，它們分別是：Field、Constructor、Method、Class、Object，下面我將對這些類做一個簡單的說明。
Field類：提供有關類或介面的屬性的信息，以及對它的動態訪問許可權。反射的欄位可能是一個類（靜態）屬性或實例屬性，簡單的理解可以把它看成一個封裝反射類的屬性的類。
Constructor類：提供關於類的單個構造方法的信息以及對它的訪問許可權。這個類和Field類不同，Field類封裝了反射類的屬性，而Constructor類則封裝了反射類的構造方法。
Method類：提供關於類或介面上單獨某個方法的信息。所反映的方法可能是類方法或實例方法（包括抽象方法）。 這個類不難理解，它是用來封裝反射類方法的一個類。
Class類：類的實例表示正在運行的 Java 應用程序中的類和介面。枚舉是一種類，注釋是一種介面。每個數組屬於被映射為 Class 對象的一個類，所有具有相同元素類型和維數的數組都共享該 Class 對象。
Object類：每個類都使用 Object 作為超類。所有對象（包括數組）都實現這個類的方法。四、Java的反射類能做什麼：
看完上面的這么多我想你已經不耐煩了，你以為我在浪費你的時間，那麼好吧！下面我們就用一些簡單的小例子來說明它。
首先我們來看一下通過Java的反射機制我們能得到些什麼。
首先我們來寫一個類：java 代碼

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
class A extends Object implements ActionListener{
private int a = 3;
public Integer b = new Integer(4);
public A(){}
public A(int id,String name){}
public int abc(int id,String name){return 0;}
public void actionPerformed(ActionEvent e){}
} 你可能被我這個類弄糊塗了，你看不出我要做什麼，那就不要看這個類了，這個類是用來測試的，你知道知道它繼承了Object類，有一個介面是ActionListener，兩個屬性int和Integer,兩個構造方法和兩個方法，這就足夠了。
下面我們把A這個類作為一個反射類，來過去A類中的一些信息，首先我們先來過去一下反射類中的屬性和屬性值。java 代碼

import java.lang.reflect.*;
class B{
public static void main(String args[]){
A r = new A();
Class temp = r.getClass();
try{
System.out.println("反射類中所有公有的屬性");
Field[] fb =temp.getFields();
for(int j=0;j<fb.length;j++){
Class cl = fb[j].getType();
System.out.println("fb:"+cl);
}

System.out.println("反射類中所有的屬性");
Field[] fa = temp.getDeclaredFields();
for(int j=0;j<fa.length;j++){
Class cl = fa[j].getType();
System.out.println("fa:"+cl);
}
System.out.println("反射類中私有屬性的值");
Field f = temp.getDeclaredField("a");
f.setAccessible(true);
Integer i = (Integer)f.get(r);
System.out.println(i);
}catch(Exception e){
e.printStackTrace();
}
}

} 這里用到了兩個方法，getFields()、getDeclaredFields()，它們分別是用來獲取反射類中所有公有屬性和反射類中所有的屬性的方法。另外還有getField(String)和getDeclaredField(String)方法都是用來過去反射類中指定的屬性的方法，要注意的是getField方法只能取到反射類中公有的屬性，而getDeclaredField方法都能取到。
這里還用到了Field 類的setAccessible方法，它是用來設置是否有許可權訪問反射類中的私有屬性的，只有設置為true時才可以訪問，默認為false。另外 Field類還有set(Object AttributeName,Object value)方法，可以改變指定屬性的值。下面我們來看一下如何獲取反射類中的構造方法java 代碼

import java.lang.reflect.*;
public class SampleConstructor {
public static void main(String[] args) {
A r = new A();
printConstructors(r);
}

public static void printConstructors(A r) {
Class c = r.getClass();
//獲取指定類的類名
String className = c.getName();
try {
//獲取指定類的構造方法
Constructor[] theConstructors = c.getConstructors();
for(int i=0; i<theConstructors.length; i++) {
//獲取指定構造方法的參數的集合
Class[] parameterTypes = theConstructors[i].getParameterTypes();

System.out.print(className + "(");

for(int j=0; j<parameterTypes.length; j++)
System.out.print(parameterTypes[j].getName() + " ");

System.out.println(")");

}
}catch(Exception e) {
e.printStackTrace();
}
}
}
這個例子很簡單,只是用getConstructors()方法獲取了反射類的構造方法的集合，並用Constructor類的getParameterTypes()獲取該構造方法的參數。下面我們再來獲取一下反射類的父類（超類）和介面java 代碼

import java.io.*;
import java.lang.reflect.*;

public class SampleInterface {
public static void main(String[] args) throws Exception {
A raf = new A();
printInterfaceNames(raf);
}

public static void printInterfaceNames(Object o) {
Class c = o.getClass();
//獲取反射類的介面
Class[] theInterfaces = c.getInterfaces();
for(int i=0; i<theInterfaces.length; i++)
System.out.println(theInterfaces[i].getName());
//獲取反射類的父類（超類）
Class theSuperclass = c.getSuperclass();
System.out.println(theSuperclass.getName());
}
} 這個例子也很簡單，只是用Class類的getInterfaces()方法獲取反射類的所有介面，由於介面可以有多個，所以它返回一個 Class數組。用getSuperclass()方法來獲取反射類的父類（超類），由於一個類只能繼承自一個類，所以它返回一個Class對象。下面我們來獲取一下反射類的方法java 代碼

import java.lang.reflect.*;
public class SampleMethod {

public static void main(String[] args) {
A p = new A();
printMethods(p);
}

public static void printMethods(Object o) {
Class c = o.getClass();
String className = c.getName();
Method[] m = c.getMethods();
for(int i=0; i<m.length; i++) {
//輸出方法的返回類型
System.out.print(m[i].getReturnType().getName());
//輸出方法名
System.out.print(" "+m[i].getName()+"(");
//獲取方法的參數
Class[] parameterTypes = m[i].getParameterTypes();
for(int j=0; j<parameterTypes.length; j++){
System.out.print(parameterTypes[j].getName());
if(parameterTypes.length>j+1){
System.out.print(",");
}
}

System.out.println(")");
}

}

} 這個例子並不難，它只是獲得了反射類的所有方法，包括繼承自它父類的方法。然後獲取方法的返回類型、方法名和方法參數。接下來讓我們回過頭來想一想，我們獲取了反射類的屬性、構造方法、父類、介面和方法，可這些東西能幫我們做些什麼呢！！
下面我寫一個比較完整的小例子，來說明Java的反射類能做些什麼吧！！java 代碼

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class LoadMethod {
public Object Load(String cName,String MethodName,String[] type,String[] param){
Object retobj = null;
try {
//載入指定的Java類
Class cls = Class.forName(cName);

//獲取指定對象的實例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);

//構建方法參數的數據類型
Class partypes[] = this.getMethodClass(type);

//在指定類中獲取指定的方法
Method meth = cls.getMethod(MethodName, partypes);

//構建方法的參數值
Object arglist[] = this.getMethodObject(type,param);

//調用指定的方法並獲取返回值為Object類型
retobj= meth.invoke(obj, arglist);

}
catch (Throwable e) {
System.err.println(e);
}
return retobj;
}

//獲取參數類型Class[]的方法
public Class[] getMethodClass(String[] type){
Class[] cs = new Class[type.length];
for (int i = 0; i < cs.length; i++) {
if(!type[i].trim().equals("")||type[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
cs[i]=Integer.TYPE;
}else if(type[i].equals("float")||type[i].equals("Float")){
cs[i]=Float.TYPE;
}else if(type[i].equals("double")||type[i].equals("Double")){
cs[i]=Double.TYPE;
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
cs[i]=Boolean.TYPE;
}else{
cs[i]=String.class;
}
}
}
return cs;
}

//獲取參數Object[]的方法
public Object[] getMethodObject(String[] type,String[] param){
Object[] obj = new Object[param.length];
for (int i = 0; i < obj.length; i++) {
if(!param[i].trim().equals("")||param[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
obj[i]= new Integer(param[i]);
}else if(type[i].equals("float")||type[i].equals("Float")){
obj[i]= new Float(param[i]);
}else if(type[i].equals("double")||type[i].equals("Double")){
obj[i]= new Double(param[i]);
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
obj[i]=new Boolean(param[i]);
}else{
obj[i] = param[i];
}
}
}
return obj;
}
} 這是我在工作中寫的一個實現Java在運行時載入指定的類，並調用指定方法的一個小例子。這里沒有main方法，你可以自己寫一個。
Load方法接收的五個參數分別是，Java的類名，方法名，參數的類型和參數的值。結束語：
Java語言反射提供一種動態鏈接程序組件的多功能方法。它允許程序創建和控制任何類的對象，無需提前硬編碼目標類。這些特性使得反射特別適用於創建以非常普通的方式與對象協作的庫。Java reflection 非常有用，它使類和數據結構能按名稱動態檢索相關信息，並允許在運行著的程序中操作這些信息。Java 的這一特性非常強大，並且是其它一些常用語言，如 C、C++、Fortran 或者 Pascal 等都不具備的。但反射有兩個缺點。第一個是性能問題。用於欄位和方法接入時反射要遠慢於直接代碼。性能問題的程度取決於程序中是如何使用反射的。如果它作為程序運行中相對很少涉及的部分，緩慢的性能將不會是一個問題。即使測試中最壞情況下的計時圖顯示的反射操作只耗用幾微秒。僅反射在性能關鍵的應用的核心邏輯中使用時性能問題才變得至關重要。

③ JAVA中重寫父類方法後，這個方法如何調用父類私有屬性方法

父類的私有屬性和方法是不被子類繼承調用的，如果你非要這么做可以
1、在父類中另外定義protected
的方法操作私有方法，子類調用該方法
2、將私有方法改為protected
3、使用反射，獲取父類所有方法，根據名稱調用

④ JAVA中反射是什麼

JAVA中反射是動態獲取信息以及動態調用對象方法的一種反射機制。

Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性；並且能改變它的屬性。而這也是Java被視為動態語言的一個關鍵性質。

Java反射的功能是在運行時判斷任意一個對象所屬的類，在運行時構造任意一個類的對象，在運行時判斷任意一個類所具有的成員變數和方法，在運行時調用任意一個對象的方法，生成動態代理。

(4)java反射父類的屬性值擴展閱讀：

JAVA中反射實例：

1、Class superClass=clazz.getSuperclass();//獲取父類。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//獲取實現介面。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//構造方法。

System.out.println("getConstructors:"+cons.length)。

參考資料來源：網路： JAVA反射機制

⑤ java 中 父類寫初始化代碼 反射獲取類中的所有屬性 並按照某種邏輯賦值(我是為了初始化Spring中的Bean)

這種想法是不可能實現的，父類中是獲取不到子類的屬性的，你需要換一個思路解決問題。

⑥ java中的反射機制是什麼有什麼作用呢求解，謝謝。

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」關注。

⑦ java 反射機制來更改父類中屬性，實際為什麼更改不了

super.methodProperty = ""; 試試看。（要顯示的調用父類要用到super 關鍵字）

⑧ 為何java中，在子類調用父類繼承來的方法時，輸出的是父類的屬性值。

兩個屬性都是私有的，子類不能繼承父類私有屬性或方法，但父類自己卻可以使用自己的私有屬性和方法，所以此處如果不重寫父類方法，則在調用show()方法時默認使用的是父類方法，調用的是父類屬性，所以輸出A中的i、j。但當子類覆蓋了，也即重寫了父類方法時，默認調用子類方法，所以輸出的是子類屬性，如果你不相信，你可以在重寫父類方法之後使用super調用重寫的方法，輸出的肯定是父類屬性，因為super是強制使用父類屬性和方法的意思，其實如果你能深入研究的話，你會發現super其實就是一個父類對象，在之心子類構造函數時jvm默認為我們創建好的。
這個地方你可以將兩個屬性換成公有的，但是有這么一句話你去體會——當子類覆蓋父類的成員變數時，父類方法使用的是父類的成員變數，子類方法使用的是子類的成員變數