同學們，如下是當日的學習目標，請同學們參照學習目標，以口語化的方式在評論區提交你的每日總結，談談你對重點知識的理解!

【理解】闡述什么是反射機制
【應用】闡述什么是字節碼對象、以及獲取的三種方式
【應用】通過反射操作構造方法、成員方法、成員屬性
【理解】闡述JavaBean的作用
【應用】獨立使用BeanUtils工具類
【應用】獨立編寫MyBeanUitls工具類

葉身輝:
      今天學習了反射,
反射是通過暴力的方法直接來獲取類中的構造和成員變量以及成員方法的
主要是通過創建該類的字節碼對象再來創建該類的對象
Forname(全類名)方法創建字節碼對象,
另外還有: 類名.class 對象名.getclass
newInstance方法來創建該類的對象(通過空參),主要的方法
另外還有:getConstructors()可以查看所有的構造方法
getConstructor()括號帶參數時例如String.class,int.class這樣寫入,不寫為空參
通過 帶有Declared的方法都是可以訪問被私有修飾的方法
調用setAccessible(true);方法可以讓java不檢查權限,之后即可對該私有的變量或者方法進行修改和調用
Field 是獲取成員變量時返回的值,  有get和set方法
Invoke( 方法名,參數 )調用成員方法的方法 參數根據方法來定
需要熟悉的單詞:
field 范圍
instance ??例證, 情況, 建議
declared ?公告的; 公然的
accessible ?易受影響的, 易接近的, 可進入的
invoke ?祈求, 實行, 懇求;
下午學習了BeanUtils工具類
主要是學習使用Populate方法來查看和修改對象中的屬性
Populate需要和Map集合一起來使用,會更加方便對對象元素的操作
以及下面兩個方法修改和查看
setProperty(Object bean,String name,Object value)
public static String getProperty(Object bean,String name)

吳利君
今天學習反思，首先學習的是獲取字節碼的獲取方式，總共3種，對象名.class，類名.class和class.forname(地址)。然后是構造方法的獲得，獲得共有的方法為class對象.getconstructor()方法，獲取所有的構造后面加個s?？梢允褂胣ewInstance方法對Constructor獲取的構造方法進行賦值！
然后是變量的獲取，首先獲取字節碼，然后創建Object對象，使用字節碼.newInstance方法獲得，然后獲取變量，這了分我公有和私有，公有為getField和getFields這兩個方法，私有的為暴力獲得，方法為getDeclaredField和getDeclaredFields
注意的是獲取私有的需要去權限，f.setAccessible(true)，然后就可以直接set賦值，然后使用f.get更新獲得新的對象，然后打印輸出。
然后是方法的獲得，首先也是獲取字節碼，創建Object對象使用使用字節碼.newInstance方法獲得，接下來獲得方法需要分為三種，首先是無參有返回值的，使用clazz.getMethod("方法名");獲得Method對象，然后使用invoke方法來接收返回的值并且賦值給Object對象。其次是無參無返回值的，這個直接使用clazz.getMethod("方法名")獲得Method對象，然后Method對象.invoke(對象)直接輸出，最后是有參無返回值的，這個在clazz.getMethod("方法名"，字節碼對象參數...)這里要注意傳入的參數要使用字節碼，并且個數統一。
當然，對于私有的還是使用帶Declared的getDeclaredMethod（）方法獲得，但是還是得注意要去權限setAccessible(true)，然后使用invoke更新。
最后是BeanUtils的使用，導包beanutils包和logging包，主要學習的是setProperty ，getProperty ，Populate 三個方法，setProperty 用來設置，getProperty 用來獲得，最后的Populate 是使用Map集合Key和反射的原理，對對象的多個值賦值，這個很好用！

   林文輝 反射總結       反射的特性比較高級,只要獲取到類名,就可以獲取到類的內部的所有成員和所有方法.就單純對程序來說確實是提高了程序的靈活性.但是同時可能帶來意料之外的問題.并且反射代碼通常比我們正常寫的代碼要麻煩,相當于拐了個彎.而且反射是通過類名對類的類部進行一系列的操作,這樣可能會導致后期維護的難度增加.
       字節碼對象說白了就是.java文件經過編譯后變成了.class,然后再加載這個類.通常的獲取方式有 類的對象.getClass(),類名.class 或者Class.forName("全類名").
       通過Class的靜態方法getConstructor()可以獲取類的public修飾的構造方法 ,getDeclaredConstructor()則比較不講道理,不管你是不是用pulibc修飾的,我一樣能把你獲取. getConstructors()和getDeclaredConstructors() 分別是返回所有的public構造方法和返回所有的構造方法,返回類型都是數組.
        getField()和getDeclaredField()和構造方法類似,沒加Declared的都是只能獲取public修飾的方法或者變量,后者則可以全部獲取,只不過必須在沒有安全限制的環境中(setAccessible(true))運行,,這也是反射的一個問題所在.
        javaBean個人認為就是類的規范,按規矩來寫類.不然總有個別喜歡搞特例的,就是不愛用private 就是喜歡protected 就是喜歡public修飾成員變量.
基本就是遵循這個幾個規范
1、所有屬性為private
2、提供默認構造方法
3、提供getter和setter
4、實現serializable接口
      BUtils是阿帕奇組織眾多的一個工具類之一,populate相對來說用處稍廣(畢竟是應用不是理解),并且也用到了雙列結合,
由此可見雙列集合在往后的開發項目是很廣的,比如網站一些的分類啊,父分類子分類這種,Map相對來說用途還是很廣的.
set get populate這幾個底層都是通過反射來實現的.編寫這幾個方法主要還是熟悉一下人家的源碼.正常來說只要知道怎么用就行了,不用管那么多,我們在編碼時，并不需要知道我們處理的JavaBeans具體是什么類型，有哪些屬性，這些信息是可以動態獲取的，甚至我們都可以不必去關心事實上是否存在這樣一個具體的JavaBean類。我們只需要知道有一個JavaBean的實例，我們需要從中取得某個屬性，設定某個屬性的值.當然有興趣就可以去研究.

反射：在程序運行時，獲取一個對象的所有信息，將其儲存到Class類的對象中，用以分析類的能力

字節碼對象，即XXXX.class文件

三種方式：
Class.forName(String);
(類的對象).getClass();
Class xxx=(類名).class

通過反射獲取一個類的所有構造器、方法、域
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

public class MyReflaction
{
        public static void main(String[] args)
        {
                Scanner sc = new Scanner(System.in);
                String className;
                if (args.length != 0)
                {
                        className = args[0];
                }
                else
                {
                        System.out.println("請輸入要查詢的類的名稱:");
                        className = sc.nextLine();
                }
                try
                {
                        Class c = Class.forName(className);
                        reflect(c);
                } catch (ClassNotFoundException e)
                {
                        System.out.println("找不到該類");
                }
        }

        public static void reflect(Class c)
        {
                // (修飾符)_class_(類名)_extends_(超類名)_implements_(接口){
                String modifiers = Modifier.toString(c.getModifiers());
                if (modifiers.length() > 0)
                {
                        System.out.print(modifiers + " class " + c.getName());
                }
                Class superClass = c.getSuperclass();
                if (superClass != Object.class)
                {
                        System.out.print(" extends " + superClass.getName());
                }
                Class[] interfaces = c.getInterfaces();
                if (interfaces.length > 0)
                {
                        System.out.print(" implements ");
                        for (int i = 0; i < interfaces.length; i++)
                        {
                                if (i > 0) System.out.print(", ");
                                System.out.print(interfaces[i].getName());
                        }
                }
                System.out.println("\r\n{");
                getAllConstructors(c);
                getAllMethods(c);
                getAllFields(c);
        }

        public static void getAllConstructors(Class c)
        {
                Constructor[] constructors = c.getDeclaredConstructors();
                for (Constructor con : constructors)
                {
                        // (\t)(修飾符)_(類名)((參數類型)_參數名){};
                        System.out.print("\t");
                        String modifiers = Modifier.toString(con.getModifiers());
                        if (modifiers.length() > 0)
                        {
                                System.out.print(modifiers + " ");
                        }
                        System.out.print(c.getName() + "(");
                        Class[] parameterTypes = con.getParameterTypes();
                        for (int i = 0; i < parameterTypes.length; i++)
                        {
                                if (i > 0) System.out.println(", ");
                                System.out.print(parameterTypes[i].getName());
                        }
                        System.out.println(");");
                }
                System.out.println();
        }

        public static void getAllMethods(Class c)
        {
                // (\t)(修飾符)_(返回值類型)_(方法名)((參數類型)){};

                Method[] methods = c.getDeclaredMethods();
                for (Method m : methods)
                {
                        System.out.print("\t");
                        String modifiers = Modifier.toString(m.getModifiers());
                        if (modifiers.length() > 0)
                        {
                                System.out.print(modifiers + " ");
                        }
                        if (m.getReturnType() != null)
                        {
                                System.out.print(m.getReturnType().getName() + " " + m.getName() + "(");
                        }
                        else
                        {
                                System.out.print("void " + m.getName() + "(");
                        }
                        Class[] parameters = m.getParameterTypes();
                        for (int i = 0; i < parameters.length; i++)
                        {
                                if (i > 0) System.out.print(", ");
                                System.out.print(parameters[i].getName());
                        }
                        System.out.println(");");
                }
                System.out.println();
        }

        public static void getAllFields(Class c)
        {
                // (\t)(修飾符)_(實例域類型)_(實例域名);
                Field[] fields = c.getDeclaredFields();
                for (Field f : fields)
                {
                        System.out.print("\t");
                        String modifiers = Modifier.toString(f.getModifiers());
                        if (modifiers.length() > 0)
                        {
                                System.out.print(modifiers + " ");
                        }
                        System.out.println(f.getType().getName() + " " + f.getName());
                }
                System.out.print("}");
        }
}

JavaBean:用于封裝數據

BeanUtils：將一些重復率高的代碼進行封裝，為了方便使用反射技術

MyBeanUitls:自己編寫的工具類，只有setProperty\getProperty\populate三個方法，
通過暴力反射獲取修改私有域，而非通過訪問器和構造器，破壞了封裝性，比較不安全，
這是與BeanUtils的區別

弄了一小時登錄終于浮上來了。
姓名:曾耀峰


   今天學的反射真是顛覆三觀，通過反射可以獲取任意一個類的所有方法和屬性，面向對象的引以為傲的三大特征之一是封裝。然而在反射面前卻毫無反擊之力。之前安卓的開發，就有提取過Andorid的字節碼文件。通過反射是否可以修改其源代碼。進而修改App軟件。有破解方法是否有防御之道？為何要設計權限這么大的機制？
   扯遠了。有空查查資料?？偨Y一下今天的學習情況。
   
   一、反射:
   1.先曬個概念，理解一下反射是什么以及它的功能:
   1).在程序運行時判斷任意一個對象所屬的類
   2).在運行時構造任意一個類的對象；
   3).在運行時能判斷和獲取一個類所具有的成員變量和方法
   4).在運行時能調用任意一個對象的方法和成員
   
   2.如何使用反射，首先利用Class對象，獲取目標類名。具體可以通過對象名.類名，通過類名.class，通過Class.forName()等三種方式調用。
   
   3.通過Class對象目標了的獲取構造，以及創建對象。有以下方式。
    1)創建無參構造函數時用Class對象的newInstance()方法
      -Class clazz
      -Object obj = clazz.newInstance（);

    2)創建有參構造函數使用Constructor對象來創建
     Constructor c = clazz.getConstructor(String.class,in.class); 這里創建出來對象參數1為String類型的變量，參數2為int類型的變量

    3)重點來了，利用反射獲取成員（當然也包括私有成員）
      （1）獲取成員變量
         [1].獲取public成員變量。要利用Class對象的方法 其中都是返回值Field[] 數組，Field對象提供了有關目標類的字段或者信息，以及對它的動態訪問權限。例如:
         Field[] getFields()方法:獲取所有公共的成員變量，返回對象數組
         Field[] getField(String name) 根據指定的字段名獲取成員變量
         Field[] getDeclaredFields() 獲取所有的成員變量，包含私有
         Filed getDeclaredField(String name) 獲取指定的成員變量，包含私有
         
      (2)獲取成員方法:還是使用Class對象的方法:
         [1].獲取public成員方法:使用getDelaredMethod()，格式如下:
             Method getMethod(String name,Class<?>...parameterTypes)
         [2].獲取private成員方法:
             使用Method  getMethod("setName",String.class) 記得開啟權限m.setAccessible(true)方法
         最后使用invoke調用執行反射出來的方法
   
    二、Beans
       Beans聽說是學習開源框架經常使用的東西。想想還是很重要的。我們以前經常寫的Person,Student等對象可以看作一個bean對象。使用方法是先導入網上下載的Bean jar包。從elispe導入。在build path里面設置變成奶瓶形狀就可以使用。
       如果一個對象要做成Bean。和以前我們寫的不一樣的兩個地方，一是實現Serials序列化接口，二是不用提供有參構造函數。
       掌握Beans的三個重要方法：
       static void      setProperty(Object bean,String name,Object value) 利用Bean對象的成員進行賦值
       static String        getProperty(Object bean, String name) // 獲取JavaBean對象的成員變量的值
       static void        populate(Object bean, Map properties)//// 給JavaBean對象的成員變量進行賦值
      
       其中使用populate方法能給對象的成員變量進行賦值
       最后學習了如何自己寫一個BeanUtils工具類。通過反射能夠很容易地寫出來
       聽說總結不用貼代碼。

張育輝
    反射是類加載字節碼文件強行獲取文件的構造和成員(成員變量,和成員方法),
之前都是通過創建對象來獲取屬性,私有方法只在本類有效,如果需要獲取,必須需要
對方提供公共的Set/get方法才能訪問,學習反射可以直接獲取.
    怎么去獲取他呢,常用的Class.forName("全類名");
    然后創建對象,newInstance();
    獲取構造方法getConstructor((可以有參數,不傳就是空參數))
    獲取成員getDeclaredField();
    獲取方法getDeclaredMethod();
    注意:訪問私有成員(成員變量,成員方法)時必須要調用setAccessible(true)方法可以讓java不檢查權限,
    后面學了一個beanUtils工具類三種方法,
                            setProperty(Object bean, String name, Object value)
                            sgetProperty(Object bean, String name)  
                            populate(Object bean, Map properties)
                    大大的提高了開發效率
                           

反射:通過字節碼對象來暴力獲取每個類中的成員 并做操作 不用在頻繁的創建每個類的對象 使用起來更面向對象???

字節碼對象:相當于一個父類? 從這個類創建的對象相當于衍生出來的子類?

獲取方法 1類名.class直接獲取  2創建對象 調用Object類的getClass()方法獲取 3通過Class類的forName方法獲取 需要傳入一個全類名(包名.類名)

反射操作成員 需要注意使用的方法 使用包含Declared可以獲取所有的成員(包括私有) 修改使用私有成員需要注意關閉java的訪問檢查(setAccessible(true))

JavaBean:跟普通類沒什么區別 有成員變量 構造方法 set get等  但是需要實現序列號接口 Serializable 為什么要實現呢 我也不懂

BeanUtils:猴哥說別記沒用的 一手        BeanUtils.populate(Object bean, Map properties)  傳入類對象和Map集合 方法會匹配成員變量并賦值 沒匹配到會報錯 需要捕獲異常自行修改

獨立編寫MyBeanUitls類 需要冷靜分析返回值 參數類型 并一步一步慢慢實現功能
                                                                                                                                 就業班涼涼的第13天  2018.05.12

  王劉鎖
   如何獲取字節碼對象:1.通過創建該類對象用對象調用getClass方法2.直接用類名.class3.用Class類的靜態方法forName(String name); Class.forName(“全類名”);
利用反射訪問成員變量 成員方法和構造方法 的方式第一種方法只能獲取被public修飾的公共的方法和屬性getField屬性   getMethod成員方法  getConstructor構造方法 要想獲取所有的方法和屬性需要用getDeclaredXxx方法需要注意的:如果要訪問私有的屬性和方法 還需要用屬性或方法對象調用setAccessible(boolean flag)方法參數寫true 可以讓程序運行時忽略權限修飾符
BeanUtils類的三個需要掌握的方法static void setProperty(Object bean,String name,Object value);設置指定對象bean的指定字段name為指定的值valuestatic String getProperty(Object bean,String name);獲取指定對象bean的指定字段name的值static void Map populate(Object bean,Map map);通過map集合中鍵和值的對應關系給該對象bean的屬性賦值 通過鍵找到對應的屬性 把鍵對應的值賦值給該屬性可能會有屬性不存在的異常需要捕獲處理

許劍鴻
day13

一 學習了反射機制,通過反射機制,可以在運行時直接獲取一個類的構造方法和成員屬性和方法或對其進行操作.

使用反射首先需要獲得類的字節碼對象 有三種方法 :
1 類名.class(屬性)
2 對象.getClass(方法)
3 Object類下方法forName()   Class.forName(全類名)



通過字節碼對象可以獲得:
1 構造方法(有參,無參) ---- 用于創建對象
2 成員變量 ---------用于獲取feild字段 對對象成員變量進行獲取或修改(訪問私有變量需先獲得權限)
3 成員方法 --------- 獲取method對象 并用invoke調用方法(訪問私有方法需先獲得權限)



二 學習了BeanUtils工具類的基本使用方法

主要用于對javabean(標準類)的封裝

學習了對javabean對象獲取值和更改值的方法

BeanUtils也是通過反射機制實現方法,以此自定BeanUtils類

葉身輝:
      今天學習了反射,
反射是通過暴力的方法直接來獲取類中的構造和成員變量以及成員方法的
主要是通過創建該類的字節碼對象再來創建該類的對象
Forname(全類名)方法創建字節碼對象,
另外還有: 類名.class 對象名.getclass
newInstance方法來創建該類的對象(通過空參),主要的方法
另外還有:getConstructors()可以查看所有的構造方法
getConstructor()括號帶參數時例如String.class,int.class這樣寫入,不寫為空參
通過 帶有Declared的方法都是可以訪問被私有修飾的方法
調用setAccessible(true);方法可以讓java不檢查權限,之后即可對該私有的變量或者方法進行修改和調用
Field 是獲取成員變量時返回的值,  有get和set方法
Invoke( 方法名,參數 )調用成員方法的方法 參數根據方法來定
需要熟悉的單詞:
field 范圍
instance ??例證, 情況, 建議
declared ?公告的; 公然的
accessible ?易受影響的, 易接近的, 可進入的
invoke ?祈求, 實行, 懇求;
下午學習了BeanUtils工具類
主要是學習使用Populate方法來查看和修改對象中的屬性
Populate需要和Map集合一起來使用,會更加方便對對象元素的操作
以及下面兩個方法修改和查看
setProperty(Object bean,String name,Object value)
public static String getProperty(Object bean,String name)

萬冕

反射是能夠操作任意的成員的一種強大的類 ,不同于我們之前學的getter,setter方法和創建類的對象來調用成員方法,反射能更加方便.


反射直接創建需要獲取的類的字節碼對象,有了字節碼對象,就能獲取到成員與有參無參構造.

class類中:  {

獲取構造(Constructor):

字節碼對象.newInstance與 getConstructor返回的對象.newInstance一樣可以獲取無參構造,但是字節碼對象.newInstance只能獲取無參構造

有參構造的括號里傳入的是數據類型.class形式傳入



獲取成員變量(Field):

用field獲取私有成員變量時,需要注意要把避開檢測開啟 field對象.setAccessible;



獲取成員方法(getmethod)


需要方法對象.invoke才能執行成員方法,invoke括號里第一個傳入的是調用的方法所在的類的對象,第二個如果有參則傳入需要賦值的參數,無參則不用填寫

調用私有成員方法時,和調用私有成員變量相同

調用有參的方法括號里第一個傳入的是方法名,第二個也是傳入數據類型.class形式.

如果方法有返回值,則要創建object對象來接收,在輸出object對象;

             }


Field類:

大致上與getter,setter

通過Field對象.get 可以獲得傳入的對象中當前字段的值

通過Field對象.set 可以設置傳入的對象中當前字段的值


BeanUtils類

主要是拿來封裝數據

三個重要的方法

static void        setProperty(Object bean, String name, Object value) 給bean對象的成員變量賦值

static String        getProperty(Object bean, String name)  獲取bean對象的成員變量的值

static void        populate(Object bean, Map properties) 利用map集合key(要賦值的成員變量名字)所對應的value(需要賦值的參數)給成員變量賦值

李志勇:
反射個人理解  掌握內容
class類  
*                         class.forName(className);
*                         類名.class
*                         對象.getclass
*                         newIstance()  調用class的空參構造
*                         getConstructor();  返回所有public 修飾的所有構造方法的數組
*                         getconstructor(參數.class);   返回制定參數的public修飾的構造方法            對象.newIstance();給成員變量賦值
*                         getField()                返回所有public修飾的成員變量對象Field 數組
*                         getField("成員變量")返回所有指定成員變量對象  Field類型
*                         getMethod()                返回所有public修飾的方法  Method類型數組接收
*                         getMethod("方法名",參數.class)                返回指定參數的方法  Method類型接收
*                         getDeclaredField()         獲取私有成員變量數組   暴力訪問返回對象.set.Accessible(boolean)true 忽略權限   
*                         getDeclaredField("成員變量") 獲取私有成員變量對象
* Field類
*                         set(Object,value)  給變量對象賦值
*                         get(object)  得到變量參數的值
* Method類
*                         invoke(object,方法參數)  運行method方法   傳入該方法類對象 和方法參數
* javabean    用了封裝數據
* BeanUtils       
*                         public static void setProperty(Object bean,String name,Object value){}       
*                         public staitc String getProperty(Object bean,String name){}       
*                         public staitc void populate(Object bean,Map map){}

邵倩

反射使我們可以獲取任意類的對象,并調用他的方法和屬性,包括私有的(暴力反射setAccessible(true)).
要使用反射的機制 首先要獲取類的對象(class對象),推薦使用class.forName(全類名)


獲取類的構造方法:
        1.所有public修飾的構造方法: Constructor [] csArr=clazz.getConstructors()
        2.無參構造方法: Constructor c=clazz.getConstructor()
        3.有參構造方法: Constructor c=clazz.getConstructor(參數類型的字節碼對象)


獲取類的對象:
        1.Object obj =clazz.newInstance().   只能創建空參構造
        2.構造方法對象.newInstance()  構造方法為空,參數列表就為空,反之則需要傳入對應類型的數據


獲取成員變量(字段):
        1.所有public修飾的成員變量:  Field[] fdArr = clazz.getFields();
        2.所有成員變量: Field[] fsArr = clazz.getDeclaredFields();
         3.根據參數獲取public修飾的字段對象: Field f= clazz.getField();
         4.根據參數獲取任意字段對象: Field f=clazz.getDeclaredField();


獲取成員方法:

用學生類舉例
第一步 獲取學生類的字節碼對象
Class clazz = Class.forName("com.itheima1.Student");
第二步 獲取學生類的對象
Object stu = clazz.newInstance();
第三步 調用以下方法      

         

1.無參無返回值的方法: Method m = clazz.getMethod(方法名);
                                            m.invoke(stu)
         2.有參無返回值的方法: Method m = clazz.getMethod(方法名,參數類型.class);
                                            m.invoke(stu,對應類型的數據)
         3.無參有返回值的方法: Method m = clazz.getMethod(方法名);
                                            Object obj=m.invoke(stu);

張清才

學習了反射的作用 相對于以前我們可以更靈活的拿到我們需要的成員;更靈活的對成員一系列的操作.

獲取class對象的三種方式
通過class方法獲取有參無參構造 創建對象
通過class不同方法獲取不同權限修飾的成員
對成員進行賦值 調用
BeanUtils工具類的三個方法.運用了反射,更簡單快捷的對成員賦值和獲取.

反射總結---陳昆明:

...............

張述明
Day13 總結
反射:就是可以使用任意的成員變量,構造方法,成員方法,使用暴力可以避免后臺的檢查,從而獲取私有的變量和方法
以下為重點內容:
通過反射獲取成員變量
1        Field[] getFields()  獲取公共的成員變量
2         Field getField(String name)  返回指定名稱字段

3        Field[] getDeclaredFields()   獲取所有的成員變量
4        Field getDeclaredField(String name)  獲取所有的成員變量(指定字段)

使用步驟
1. 通過反射獲取該類的字節碼對象
Class clazz = Class.forName("");
2. 創建該類對象
Object p = clazz.newInstance();
3. 獲取該類中需要操作的字段(成員變量)
getField(String name)  方法傳入字段的名稱.
Field f = clazz.getField("如name");
4. 通過字段對象中的方法修改屬性值
void set(Object obj, Object value)  --> 參數1): 要修改那個對象中的字段, 參數2):
f.set(p,要修改的值 );
通過反射操作私有成員變量
使用步驟
1.        獲取類字節碼對象
2. 獲取lei對象
3. 通過getDeclaredField方法獲取私有字段
4. 通過setAccessible讓jvm不檢查權限
5. 通過set方法設置對象為具體的值
通過反射獲取成員方法并使用
反射獲取普通成員方法
反射public方法執行流程
1.        獲取學生類字節碼對象
2. 反射手段創建學生對象
3. 調用getMethod方法獲取Method對象, 方法形參接受方法的名字
4. 調用Method方法中的invoke()將方法運行

Javabean
1.        用于封裝數據
2.        Public修飾類
3.        私有成員變量
4.        提供get/Set方法
5.        提供公共無參構造
6.        實現序列號接口

BeanUtils的使用
作用:簡化javabean封裝數據的操作.
public static void setProperty(Object bean,String name,Object value)
// 設置任意對象的, 任意屬性, 為任意的值
public static String getProperty(Object bean,String name)
        // 獲取任意對象的任意屬性
        public static void populate(Object bean,Map map)
        // 修改任意對象中的屬性, 為傳入Map集合中的鍵和值

白有旺
今天學習了如何通過反射獲取類中的構造方法,成員變量(包括私有的),還有成員方法,知識點太多,下午的工具類有點模仿,有待加強

杜石葦
反射很強大 能獲取任意類的所有屬性和方法
字節碼對象是由類對象獲取而來  可以用三種方法獲取  用類名.class 或者類名對象.getclass 或者class.forName(類名路徑)
反射的操作方法一般用字節碼對象getDeclared后面加filead或者method或者 Constructor都可以獲取私有變量,方法,構造
私有,方法,構造變量要設置必須暴力訪問 setAccessible(true);
BeanUtils工具類是更方便的使用反射方法  底層也是有反射方法寫的  也學習了簡單的寫了Mybean
對象和HashMap結合來使用 bean populate的這個方法很好用

張述明

反射:就是可以使用任意的成員變量,構造方法,成員方法,使用暴力可以避免后臺的檢查,從而獲取私有的變量和方法
以下為重點內容
通過反射獲取成員變量
1        Field[] getFields()  獲取公共的成員變量
2         Field getField(String name)  返回指定名稱字段

3        Field[] getDeclaredFields()   獲取所有的成員變量
4        Field getDeclaredField(String name)  獲取所有的成員變量(指定字段)

使用步驟
1. 通過反射獲取該類的字節碼對象
Class clazz = Class.forName("");
2. 創建該類對象
Object p = clazz.newInstance();
3. 獲取該類中需要操作的字段(成員變量)
getField(String name)  方法傳入字段的名稱.
Field f = clazz.getField("如name");
4. 通過字段對象中的方法修改屬性值
void set(Object obj, Object value)  --> 參數1): 要修改那個對象中的字段, 參數2):
f.set(p,要修改的值 );
通過反射操作私有成員變量
使用步驟
1.        獲取類字節碼對象
2. 獲取lei對象
3. 通過getDeclaredField方法獲取私有字段
4. 通過setAccessible讓jvm不檢查權限
5. 通過set方法設置對象為具體的值
通過反射獲取成員方法并使用
反射獲取普通成員方法
反射public方法執行流程
1.        獲取學生類字節碼對象
2. 反射手段創建學生對象
3. 調用getMethod方法獲取Method對象, 方法形參接受方法的名字
4. 調用Method方法中的invoke()將方法運行

Javabean
1.        用于封裝數據
2.        Public修飾類
3.        私有成員變量
4.        提供get/Set方法
5.        提供公共無參構造
6.        實現序列號接口

BeanUtils的使用
作用:簡化javabean封裝數據的操作.
public static void setProperty(Object bean,String name,Object value)
// 設置任意對象的, 任意屬性, 為任意的值
public static String getProperty(Object bean,String name)
        // 獲取任意對象的任意屬性
        public static void populate(Object bean,Map map)
        // 修改任意對象中的屬性, 為傳入Map集合中的鍵和值

seilye 發表于 2018-5-12 21:21
葉身輝:
      今天學習了反射,
反射是通過暴力的方法直接來獲取類中的構造和成員變量以及成員方法的

很不錯！

陳強
通過獲取字節碼對象,調用newInstance的方法創建對象.

通過反射,可以獲取構造方法,成員變量,成員方法.
1,構造方法---getConstructor(根據指定參數獲取對應的構造),getConstructors(獲取所有public修飾的構造方法)
2,成員變量---private修飾的私有成員變量需放開權限---setAccessible---getDeclaredField
3,成員方法---非私有成員方法注意getMethod分為(無參無返回值,有參無返回值,無參有返回值),private修飾的成員方法注意需放開權限---setAccessible---getDeclaredMethod

JavaBean類---標準類
較之前類的格式,增加該類需要實現序列化接口---Serializable

BeanUtils的方法:
1,setProeperty\getProeperty---變量名應為String類型
2,populate方法---( Object bean , Map  map )---Map <String , Object  >  map = new HashMap<>( ) ;
遍歷map集合,根據key獲取Field對象,根據key獲取Value
使用populate方法,try...catch,捕獲的異常為NoSuchFieldException