传智教育旗下技术交流社区北京校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 厦门校区 黑马粉丝团   /  2018-5-12 15:02  /  6249 人查看  /  97 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

同学们,如下是当日的学习目标,请同学们参照学习目标,以口语化的方式在评论区提交你的每日总结,谈谈你对重点知识的理解!

【理解】阐述什么是反射机制
【应用】阐述什么是字节码对象、以及获取的三种方式
【应用】通过反射操作构造方法、成员方法、成员属性
【理解】阐述JavaBean的作用
【应用】独立使用BeanUtils工具类
【应用】独立编写MyBeanUitls工具类
分享至 : QQ空间
收藏

97 个回复

倒序浏览
叶身辉:
      今天学习了反射,
反射是通过暴力的方法直接来获取类中的构造和成员变量以及成员方法的
主要是通过创建该类的字节码对象再来创建该类的对象
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)

点评

用自己的话把当天重要的知识整理的很清楚  发表于 2018-5-13 11:48
回复 使用道具 举报
吴利君
今天学习反思,首先学习的是获取字节码的获取方式,总共3种,对象名.class,类名.class和class.forname(地址)。然后是构造方法的获得,获得共有的方法为class对象.getconstructor()方法,获取所有的构造后面加个s。可以使用newInstance方法对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和反射的原理,对对象的多个值赋值,这个很好用!

点评

一段话把当天的内容阐述明白了  发表于 2018-5-13 11:47
回复 使用道具 举报
本帖最后由 磬辰 于 2018-5-12 22:03 编辑

   林文辉 反射总结       反射的特性比较高级,只要获取到类名,就可以获取到类的内部的所有成员和所有方法.就单纯对程序来说确实是提高了程序的灵活性.但是同时可能带来意料之外的问题.并且反射代码通常比我们正常写的代码要麻烦,相当于拐了个弯.而且反射是通过类名对类的类部进行一系列的操作,这样可能会导致后期维护的难度增加.
       字节码对象说白了就是.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的实例,我们需要从中取得某个属性,设定某个属性的值.当然有兴趣就可以去研究.

点评

对于反射的理解很深刻  发表于 2018-5-13 11:47
回复 使用道具 举报 1 0
反射:在程序运行时,获取一个对象的所有信息,将其储存到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的区别

点评

口语化的思考总结较少,但提供的代码很优质,供大家学习  发表于 2018-5-13 11:46
代码质量很高!  发表于 2018-5-12 23:21

评分

参与人数 1技术分 +3 黑马币 +4 收起 理由
厦门校区 + 3 + 4 很给力!

查看全部评分

回复 使用道具 举报 1 0
弄了一小时登录终于浮上来了。
姓名:曾耀峰


   今天学的反射真是颠覆三观,通过反射可以获取任意一个类的所有方法和属性,面向对象的引以为傲的三大特征之一是封装。然而在反射面前却毫无反击之力。之前安卓的开发,就有提取过Andorid的字节码文件。通过反射是否可以修改其源代码。进而修改App软件。有破解方法是否有防御之道?为何要设计权限这么大的机制?
   扯远了。有空查查资料。总结一下今天的学习情况。
   
   一、反射:
   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工具类。通过反射能够很容易地写出来
       听说总结不用贴代码。

点评

很不错,能够用自己的语言描述自己的思路,代码的理解不只是简单的应用。更多的是能够用最简单的语言解释清楚最复杂的代码。加油!  发表于 2018-5-14 11:09
不仅仅是概括全面,而是真正思考了学完反射和之前内容的区别所在  发表于 2018-5-13 11:46
回复 使用道具 举报 1 0
本帖最后由 finfin12 于 2018-5-12 21:52 编辑

张育辉
    反射是类加载字节码文件强行获取文件的构造和成员(成员变量,和成员方法),
之前都是通过创建对象来获取属性,私有方法只在本类有效,如果需要获取,必须需要
对方提供公共的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)
                    大大的提高了开发效率
                           
回复 使用道具 举报

张裕

本帖最后由 六道的骸6 于 2018-5-12 21:35 编辑

反射:通过字节码对象来暴力获取每个类中的成员 并做操作 不用在频繁的创建每个类的对象 使用起来更面向对象???

字节码对象:相当于一个父类? 从这个类创建的对象相当于衍生出来的子类?

获取方法 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
回复 使用道具 举报
本帖最后由 13163997058 于 2018-5-12 21:59 编辑

  王刘锁
   如何获取字节码对象: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的属性赋值 通过键找到对应的属性 把键对应的值赋值给该属性可能会有属性不存在的异常需要捕获处理







13.txt

4.15 KB, 下载次数: 74

回复 使用道具 举报
许剑鸿
day13

一 学习了反射机制,通过反射机制,可以在运行时直接获取一个类的构造方法和成员属性和方法或对其进行操作.

使用反射首先需要获得类的字节码对象 有三种方法 :
1 类名.class(属性)
2 对象.getClass(方法)
3 Object类下方法forName()   Class.forName(全类名)



通过字节码对象可以获得:
1 构造方法(有参,无参) ---- 用于创建对象
2 成员变量 ---------用于获取feild字段 对对象成员变量进行获取或修改(访问私有变量需先获得权限)
3 成员方法 --------- 获取method对象 并用invoke调用方法(访问私有方法需先获得权限)



二 学习了BeanUtils工具类的基本使用方法

主要用于对javabean(标准类)的封装

学习了对javabean对象获取值和更改值的方法

BeanUtils也是通过反射机制实现方法,以此自定BeanUtils类
回复 使用道具 举报 1 0
叶身辉:
      今天学习了反射,
反射是通过暴力的方法直接来获取类中的构造和成员变量以及成员方法的
主要是通过创建该类的字节码对象再来创建该类的对象
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 0
万冕

反射是能够操作任意的成员的一种强大的类 ,不同于我们之前学的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){}
回复 使用道具 举报
本帖最后由 望蜀 于 2018-5-13 02:31 编辑

邵倩

反射使我们可以获取任意类的对象,并调用他的方法和属性,包括私有的(暴力反射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);




回复 使用道具 举报
本帖最后由 2902 于 2018-5-12 21:32 编辑

张清才

学习了反射的作用 相对于以前我们可以更灵活的拿到我们需要的成员;更灵活的对成员一系列的操作.

获取class对象的三种方式
通过class方法获取有参无参构造 创建对象
通过class不同方法获取不同权限修饰的成员
对成员进行赋值 调用
BeanUtils工具类的三个方法.运用了反射,更简单快捷的对成员赋值和获取.
回复 使用道具 举报
反射总结---陈昆明:
反射总结.PNG
回复 使用道具 举报
本帖最后由 六道的骸6 于 2018-5-13 11:34 编辑

...............
回复 使用道具 举报
张述明
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
回复 使用道具 举报
12345下一页
您需要登录后才可以回帖 登录 | 加入黑马