java反射類屬性
㈠ 什麼是java的反射
Java反射指的是對於任何的一個java類，我們都可以通過反射獲取到這個類的所有屬性和方法(包含私有的屬性方法)，使用java反射我們也可以調用一個對象的任何方法。
我們知道Java是一門面向對象編程的語言，我們編程的時候，經常會將類的屬性進行封裝，然後提供public方法進行屬性的設置和獲取。類的屬性我們通常會設置成private的私有屬性，為的就是保護對象屬性不被隨意的修改和訪問。但是反射機制卻恰恰相反，通過反射，我們可以獲取到這些被保護的屬性和方法，並且可以修改和訪問他們。
在java中我們可以使用object對象的getClass();方法獲得Class的對象classObject;語法格式為 Class classObject = object.getClass() ;可以根據Class對象的方法獲取object對象的相關屬性和方法;
獲取object對象的名字可以使用 classObject.getName();獲取類的名稱，獲取到的結果包含包的名稱;
獲取object對象的包名稱，可以使用classObject.getPackage();獲取包的名稱;
獲取object對象的所有public屬性，可以使用classObject.getFields();方法，返回列表是屬性類Field[]對象列表;
獲取object對象所有屬性,可以使用classObject.getDeclaredFields();方法，返回的是所有屬性列表(包含private屬性);
獲取object對象某個特定的屬性,可以使用classObject.getField( fieldName );可以根據屬性名稱獲取屬性類的對象;
獲取object對象private屬性，可以使用classObject.getDeclaredField( fieldName );根據屬性名獲取屬性對象信息;
獲取object對象public方法，使用classObject.getMethods();可以獲取到方法類Method[]對象列表;
獲取object對象某個特定的public方法，使用classObject.getMethod( funName , Class... parameterTypes);根據方法名和方法參數類型列表，可以獲取到方法類的對象;
獲取object對象所有方法(包含private方法);使用classObject.getDeclaredMethods();可以獲取所有的方法對象列表;
獲取object對象某個特定方法(包含private方法)，使用classObject.getDeclaredMethod ( funName, Class... parameterTypes );根據方法名和方法參數類型列表，可以獲取到類的特定方法(包含private方法);
獲取object對象類中所有的public構造方法，可以使用classObject.getConstructors(); 獲取到構造類Constructor的對象列表;
獲取object對象類中某個特定的構造方法，可以使用classObject.getConstructor( Class... parameterTypes ); 根據參數類型列表，獲取指定的構造函數對象;
獲取object對象類中所有的構造方法(包含private)，可以使用classObject.getDeclaredConstructors(); 獲取到構造類Constructor的對象列表;
獲取object對象類中某個特定的構造方法(包含private)，可以使用classObject.getDeclaredConstructor( Class... parameterTypes ); 根據參數類型列表，獲取指定的構造函數對象;
㈡ 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(); //與上面的方法等價
㈢ 如何利用java反射機制往.java文件中添加屬性
class
c
=
class.forname("student");
//通過字元串裝載類,
必須是絕對路徑,
即包括包名
object
o
=
c.newinstance();
//獲取裝載類的實例,
如果找不到就會拋出異常
class[]
cs=
{sting.class,int.class};
//定義一個類的數組,
一般這種都是用在method的參數列表
//string.class說明傳的是類型
method
m
=
c.getmethod("study",cs);
//獲取裝載類的實例的study方法,
注意後面的參數,
class[]
ca
=
{"tom",18}
//和上面有點不同,
這里傳的是值
object
result
=
m.invoke(o,ca);
//執行method方法,並獲取結果
反射一般都用在類名,欄位,方法可以隨便變化的時候,
還可以進行統一的處理,提高擴展性
比如說hibernate框架的實體類,
預先你不可能知道實體類會有什麼欄位,
包括欄位的類型都是有可能隨意變化的,
這時候要獲取指定類的欄位信息就必須得使用反射了.
還有struts的actionform等都一樣
以上純屬個人意見,
學得不是很深,希望能給你帶來幫助
㈣ Java的反射到底有什麼用途
反射的作用可謂是博大精深，
JDK動態代理生成代理類的位元組碼後，首先把這個類通過defineclass定義成一個類，然後用class.for(name)會把該類載入到jvm，之後我們就可以通過，A.class.GetMethod()獲取其方法，然後通過invoke調用其方法，在調用這個方法時，實際上會通過被代理類的引用再去調用原方法。
Java反射包reflection提供對Class，Method，field，constructor1 等信息的封裝類型
通過這些api可以輕易獲得一個類的各種信息並且可以進行實例化，方法調用等。
類中的private參數可以通過setaccessible方法強制獲取。
㈤ 什麼是反射什麼Java反射
java反射是什麼意思呢？下面帶大家了解一下。
JAVA反射是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力。反射是一種強大的工具，能夠創建靈活的代碼，可以使代碼在運行時裝配，無需在組件之間進行源代表鏈接。
JAVA反射機制是在運行狀態中，知道所有屬性和方法，對於任意一個對象，能夠調用它的方法和屬性，這種動態獲取的信息以及動態調用對象的方法的功能的反射機制。
反射適合用在哪
首先我們先思考一個問題，反射適合使用在哪裡呢？從功能上看，反射似乎無所不能，幾乎所有的類，所有的屬性、方法、構造我們都能使用，但是我們細細思考一下，在實際開發中，並不是所有場景都需要使用反射獲取屬性或者方法進行操作，反而更多的使用實例.xxx方式操作，而當這些操作重復次數較多的時候，我們往往會考慮優化代碼，減少代碼冗餘，提高復用，比如實體構建賦值等操作，這個時候往往是我們最需要復用的地方，所以我們可以大體認為反射主要使用在實體操作過程中。而在一般操作數據的過程中，我們的實體一般都是知道並且依賴於對應的數據類型的，比如:
1.根據類型new的方式創建對象
2.根據類型定義變數，類型可能是基本類型也可能是引用類型、類或者介面
3.將對應類型的對象傳遞給方法
4.根據類型訪問對象的屬性，調用方法等操作
以上這些操作都是數據操作的過程中最常見也是最難復用優化的地方，而如果這里的操作使用反射則可以實現動態的操作不同的類型的實例，通過調用反射入口類Class，獲取對應的屬性、構造、方法完成對應的操作
㈥ java怎麼通過反射得到屬性的類型
Class<?>cls=Class.forName(className);//通過類的名稱反射類
Objectobj=cls.newInstance();//對象實例化
Fieldfield=cls.getField(fieldName);//這個對應的是屬性
fieldValue=field.get(obj);//這個就是屬性的值
㈦ java中什麼是反射，反射怎麼用，什麼場景用有沒有替代方案
1、反射簡言之就是在編譯時無法拿到某一個類，但是可以在運行時動態獲取這個類，這樣去使用某一個類，就是反射的使用場景。
2、代替反射或者類似的操作，可以通過DI實現IOC .依賴注入，動態代理。
㈧ java中如何通過反射獲取類的屬性
簡單的方法如下：
Class<?> cls=Class.forName(className);////////////////////////通過類的名稱反射類
Object obj=cls.newInstance();//////////////////////對象實例化
Field field=cls.getField(fieldName);/////這個對應的是屬性
fieldValue=field.get(obj);////這個就是屬性的值
㈨ 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餘年高校項目實踐畢設指導經驗；企業軟培經驗豐富
㈩ JAVA中反射是什麼
JAVA中反射是動態獲取信息以及動態調用對象方法的一種反射機制。
Java反射就是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意方法和屬性；並且能改變它的屬性。而這也是Java被視為動態語言的一個關鍵性質。
Java反射的功能是在運行時判斷任意一個對象所屬的類，在運行時構造任意一個類的對象，在運行時判斷任意一個類所具有的成員變數和方法，在運行時調用任意一個對象的方法，生成動態代理。
(10)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反射機制