黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】反射 [打印本页]
作者: 厦门校区 时间: 2018-5-12 15:02
标题: 【厦门JavaEE就业1期-每日总结】反射
同学们，如下是当日的学习目标，请同学们参照学习目标，以口语化的方式在评论区提交你的每日总结，谈谈你对重点知识的理解!
【理解】阐述什么是反射机制
【应用】阐述什么是字节码对象、以及获取的三种方式
【应用】通过反射操作构造方法、成员方法、成员属性
【理解】阐述JavaBean的作用
【应用】独立使用BeanUtils工具类
【应用】独立编写MyBeanUitls工具类
作者: finfin12 时间: 2018-5-12 18:29
本帖最后由 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 18:38
标题: 张裕
本帖最后由 六道的骸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 20:46
本帖最后由 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, 下载次数: 160
作者: 许大炮 时间: 2018-5-12 21:21
许剑鸿
day13
一 学习了反射机制,通过反射机制,可以在运行时直接获取一个类的构造方法和成员属性和方法或对其进行操作.
使用反射首先需要获得类的字节码对象 有三种方法 :
1 类名.class(属性)
2 对象.getClass(方法)
3 Object类下方法forName() Class.forName(全类名)
通过字节码对象可以获得:
1 构造方法(有参,无参) ---- 用于创建对象
2 成员变量 ---------用于获取feild字段 对对象成员变量进行获取或修改(访问私有变量需先获得权限)
3 成员方法 --------- 获取method对象 并用invoke调用方法(访问私有方法需先获得权限)
二 学习了BeanUtils工具类的基本使用方法
主要用于对javabean(标准类)的封装
学习了对javabean对象获取值和更改值的方法
BeanUtils也是通过反射机制实现方法,以此自定BeanUtils类
作者: seilye 时间: 2018-5-12 21:21
叶身辉:
今天学习了反射,
反射是通过暴力的方法直接来获取类中的构造和成员变量以及成员方法的
主要是通过创建该类的字节码对象再来创建该类的对象
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)
作者: seilye 时间: 2018-5-12 21:22
叶身辉:
今天学习了反射,
反射是通过暴力的方法直接来获取类中的构造和成员变量以及成员方法的
主要是通过创建该类的字节码对象再来创建该类的对象
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)
作者: 咸鱼coder 时间: 2018-5-12 21:22
万冕
反射是能够操作任意的成员的一种强大的类 ,不同于我们之前学的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(需要赋值的参数)给成员变量赋值
作者: 李志勇 时间: 2018-5-12 21:22
李志勇:
反射个人理解 掌握内容
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-12 21:22
本帖最后由 望蜀 于 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:31
本帖最后由 2902 于 2018-5-12 21:32 编辑
张清才
学习了反射的作用 相对于以前我们可以更灵活的拿到我们需要的成员;更灵活的对成员一系列的操作.
获取class对象的三种方式
通过class方法获取有参无参构造 创建对象
通过class不同方法获取不同权限修饰的成员
对成员进行赋值 调用
BeanUtils工具类的三个方法.运用了反射,更简单快捷的对成员赋值和获取.
作者: conan75 时间: 2018-5-12 21:32
反射总结---陈昆明:
-
反射总结.PNG
(94.59 KB, 下载次数: 102)
作者: 六道的骸6 时间: 2018-5-12 21:33
本帖最后由 六道的骸6 于 2018-5-13 11:34 编辑
...............
作者: 张述明 时间: 2018-5-12 21:33
张述明
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集合中的键和值
作者: avip0000 时间: 2018-5-12 21:35
白有旺
今天学习了如何通过反射获取类中的构造方法,成员变量(包括私有的),还有成员方法,知识点太多,下午的工具类有点模仿,有待加强
作者: w849027724 时间: 2018-5-12 21:36
吴利君
今天学习反思，首先学习的是获取字节码的获取方式，总共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和反射的原理，对对象的多个值赋值，这个很好用！
作者: rkko 时间: 2018-5-12 21:36
杜石苇
反射很强大 能获取任意类的所有属性和方法
字节码对象是由类对象获取而来 可以用三种方法获取 用类名.class 或者类名对象.getclass 或者class.forName(类名路径)
反射的操作方法一般用字节码对象getDeclared后面加filead或者method或者 Constructor都可以获取私有变量,方法,构造
私有,方法,构造变量要设置必须暴力访问 setAccessible(true);
BeanUtils工具类是更方便的使用反射方法 底层也是有反射方法写的 也学习了简单的写了Mybean
对象和HashMap结合来使用 bean populate的这个方法很好用
作者: 张述明 时间: 2018-5-12 21:38
张述明
反射:就是可以使用任意的成员变量,构造方法,成员方法,使用暴力可以避免后台的检查,从而获取私有的变量和方法
以下为重点内容
通过反射获取成员变量
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集合中的键和值
作者: 厦门校区 时间: 2018-5-12 21:39
很不错！
作者: 厦门陈强 时间: 2018-5-12 21:39
陈强
通过获取字节码对象,调用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
作者: 张述明 时间: 2018-5-12 21:40
张述明
反射:就是可以使用任意的成员变量,构造方法,成员方法,使用暴力可以避免后台的检查,从而获取私有的变量和方法
以下为重点内容
通过反射获取成员变量
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集合中的键和值
作者: 一梦 时间: 2018-5-12 21:41
陈世彪:
反射,java在运行中,我们可以通过反射获取它字节码文件里所有的东西,例如成员变量,成员方法,构造方法,包括私有的
Object obj = c.newInstance("lisi",30); 创建对象,并往里面赋值
Field[] getDeclaredFields() //获取所有的成员变量 包含私有
再加上setAccessible(true);//设置反射时取消Java的访问检查,暴力访问
操作成员方法
Public static void method(){}
1无参无返回值
Public static int method(){}
2 无参有返回值
Public static void method(参数){}
3 有参无返回值
BeanUtils工具类常用的三种方法
1 setProperty 用来给对象中的属性赋值
2 getProperty 用来获取对象中的属性
3 Populate 用来给对象中的属性赋值
独立编写MyBeanUitls工具类
记得要捕获异常,避免出没有的参数
catch (NoSuchFieldException e)
作者: 李思贤126 时间: 2018-5-12 21:46
李思贤
反射,通过class(3种)可以在编译时期就能获取该类所有的构造方法,成员变量,
成员方法.
Constructors(遍历得到构造方法后不能构造对象,因为JDK不知道他是空参还是有参)!!
想要构造对象要用Constructor.之后用newInstance就能构造对象.
下面是成员,getFileld和getMethod用法差不多,非私有的要注意用中间带Declared这个的,
还要注意让JDK留个小门setAccessible.
最后面是BeanUtils,会个populate就行了.(以上方法详情见学习笔记或者视频).
作者: 5119 时间: 2018-5-12 21:46
游荣辉
今天学会了反射,反射就是我们再编译时期可以获得的所有成员
反射获取字节码对象的三种方式,虽然以前有说过可是记不太清,可是今天记住了Class.forName(全类名),对象名.getclass,类名.class
还学会了反射操作构造方法先拿到他的字节码对象,用字节码对象调用getConstructor方法,得到他的空参构造,如果有参数那么根据参数获得有参构造.
运用反射操作成员变量操作成员方法
成员变量
(获取public的成员变量)
使用字节码对象调用Field getField(String name) 获得所有的public修饰的成员变量,可用set方法来更改变量的值.get来获取变量的值
(获取所有成员对象)
使用字节码对象调用Field getDeclaredField(String name)获得所有的成员变量包括私有的.可是想要获得它私有的成员必须先把setAccessible(true)开了,这样就可以获取或者更改变量了.
成员方法
获取成员方法的方式跟获取成员变量的方式差不多,用字节码调用getDeclaredMethod(所有的成员方法)获取getMethod(public修饰的成员方法),使用invoke来获取方法,当然私有的也要setAccessible(true).
还学了JavaBean他是用来封装用的,
BeanUtils 是用来为了能更简单的操作JavaBean的,它的最底层是由反射构成的,使用有好多异常;学了它的三个方法,有两个老师说 setProperty getProperty(是有返回值的) populate这个第一个参数是一个对象,第二个参数是一个Map集合,Map集合的第一个参数是记录成员变量的,第二个是记录值的
作者: w849027724 时间: 2018-5-12 21:46
吴利君
今天学习反思，首先学习的是获取字节码的获取方式，总共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和反射的原理，对对象的多个值赋值，这个很好用！
作者: Ldddd 时间: 2018-5-12 21:46
赖镇东 （每日总结）
反射
今天学习到了反射，我对反射的理解就是可以直接获得任意类的任意成员和成员方法。
1， 复习了获取字节码的三总方法
（1） 根据对象
（2） 根据类名
（3） 根据Class
2， 学习了反射机制，利用字节码对象
（1） 获取构造方法
（2） 获取成员变量的对象，并用set，get赋值取值（公有可以用getFiled,其他的要用getDeclaredField，并提前解开访问，setAccessible打开权限）
（3） 获取成员方法(同成员变量一样，私有方法要注意使用的方法，也需要提前打开权限)
3， BeanUtils
（1） 学会三个常用方法
（2） 自己创键一个BeanUtils
作者: wahahaha 时间: 2018-5-12 21:46
林恒山
反射:在运行程序过程中,获取类的所有成员
字节码对象获取方式:1对象.getClass() 2类名.class 3Class.forName(“全类名”)
反射操作构造方法/成员变量/成员方法:
构造方法: Constructor<?>[] getConstructors() 获取所有public的构造方法对象的集合
Constructor<T> getConstructor(Class<?>... parameterTypes) 根据指定的参数获取对应的构造方法对象
成员方法: Method[] getMethods() 获取所有的public的方法对象的集合
Method getMethod(String name, Class<?>... parameterTypes) 根据给定的参数获取对应public方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes) 根据给定的参数获取对应方法对象(包括私有的) 成员方法调用void setAccessible(boolean flag) 实现取消java的权限检查
成员属性:Field[] getdFields() 获取所有的public 的成员属性对象的集合
Field getField(String name) 根据参数获得指定的public成员属性对象
Field getDeclaredField(String name) 根据参数获得指定的成员属性对象(包括私有的) 成员属性调用void setAccessible(boolean flag) 实现取消java的权限检查
BeanUtils的常用方法 populate
作者: LittleSky 时间: 2018-5-12 21:47
常小天
反射：通过字节码对象获取并调用任意类的任意成员，包括私有的。
字节码文件：由程序员编写的程序转换而成的能然机器读懂的文件。
反射的使用：
1、获取字节码对象
2、通过字节码对象调用newInstance方法创建类的无参构造对象，或者通过字节码对象调用getConstructor方法获取构造方法对象，再通过构造方法对象调用newInstance(实际参数列表)方法创建类的对象。
3、通过字节码对象调用getDeclaredFields()方法获取成员变量对象，再通过获取的成员变量对象调用setAccessible方法取消变量权限检测，最后通过成员变量对象调用get(Object obj)方法和set(Object obj)方法对成员变量进行操作。
4、通过字节码对象调用get DeclaredMethod(String name,参数类型.Class…)方法获取成员方法对象，通过成员方法对象调用setAccessible方法取消变量权限检测，最后通过调用invoke(Object obj,实际参数列表)方法执行自身所指代的方法。
JavaBean：标准类
BeanUtils的作用：简化了JavaBean的封装数据的操作
BeanUtils重点方法：
static void populate(Object bean, Map properties) 通过map键值对给指定对象的成员变量进行赋值
自定义BeanUtils工具类：核心为通过反射获取字节码对象，通过字节码对象获取成员的对象，通过成员对象调用方法获取和设置变量值，可使用暴力反射
作者: 5119 时间: 2018-5-12 21:47
游荣辉
今天学会了反射,反射就是我们再编译时期可以获得的所有成员
反射获取字节码对象的三种方式,虽然以前有说过可是记不太清,可是今天记住了Class.forName(全类名),对象名.getclass,类名.class
还学会了反射操作构造方法先拿到他的字节码对象,用字节码对象调用getConstructor方法,得到他的空参构造,如果有参数那么根据参数获得有参构造.
运用反射操作成员变量操作成员方法
成员变量
(获取public的成员变量)
使用字节码对象调用Field getField(String name) 获得所有的public修饰的成员变量,可用set方法来更改变量的值.get来获取变量的值
(获取所有成员对象)
使用字节码对象调用Field getDeclaredField(String name)获得所有的成员变量包括私有的.可是想要获得它私有的成员必须先把setAccessible(true)开了,这样就可以获取或者更改变量了.
成员方法
获取成员方法的方式跟获取成员变量的方式差不多,用字节码调用getDeclaredMethod(所有的成员方法)获取getMethod(public修饰的成员方法),使用invoke来获取方法,当然私有的也要setAccessible(true).
还学了JavaBean他是用来封装用的,
BeanUtils 是用来为了能更简单的操作JavaBean的,它的最底层是由反射构成的,使用有好多异常;学了它的三个方法,有两个老师说 setProperty getProperty(是有返回值的) populate这个第一个参数是一个对象,第二个参数是一个Map集合,Map集合的第一个参数是记录成员变量的,第二个是记录值的
作者: 一梦 时间: 2018-5-12 21:47
本帖最后由 一梦 于 2018-5-13 00:15 编辑
陈世彪：
反射,java在运行中,我们可以通过反射获取它字节码文件里所有的东西,例如成员变量,成员方法,构造方法,包括私有的
通过获取的构造创建对象
步骤:
1.获得Class对象
2获得构造
3.通过构造对象获得实例化对象
操作成员方法
Public static void method(){}
1无参无返回值
Public static int method(){}
2 无参有返回值
Public static void method(参数){}
3 有参无返回值
Object obj =c.newInstance("lisi",30); 创建对象
FieldgetDeclaredField(String name) //获取指定的成员变量 包含私有
setAccessible(true);//设置反射时取消Java的访问检查,暴力访问
1setProperty 用来给对象中的属性赋值
2getProperty 用来获取对象中的属性
3Populate 用来给对象中的属性赋值
catch(NoSuchFieldException e) {}
自定义工具类时捕获异常并抛出
作者: w849027724 时间: 2018-5-12 21: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和反射的原理，对对象的多个值赋值，这个很好用！
作者: 5119 时间: 2018-5-12 21:48
游荣辉
今天学会了反射,反射就是我们再编译时期可以获得的所有成员
反射获取字节码对象的三种方式,虽然以前有说过可是记不太清,可是今天记住了Class.forName(全类名),对象名.getclass,类名.class
还学会了反射操作构造方法先拿到他的字节码对象,用字节码对象调用getConstructor方法,得到他的空参构造,如果有参数那么根据参数获得有参构造.
运用反射操作成员变量操作成员方法
成员变量
(获取public的成员变量)
使用字节码对象调用Field getField(String name) 获得所有的public修饰的成员变量,可用set方法来更改变量的值.get来获取变量的值
(获取所有成员对象)
使用字节码对象调用Field getDeclaredField(String name)获得所有的成员变量包括私有的.可是想要获得它私有的成员必须先把setAccessible(true)开了,这样就可以获取或者更改变量了.
成员方法
获取成员方法的方式跟获取成员变量的方式差不多,用字节码调用getDeclaredMethod(所有的成员方法)获取getMethod(public修饰的成员方法),使用invoke来获取方法,当然私有的也要setAccessible(true).
还学了JavaBean他是用来封装用的,
BeanUtils 是用来为了能更简单的操作JavaBean的,它的最底层是由反射构成的,使用有好多异常;学了它的三个方法,有两个老师说 setProperty getProperty(是有返回值的) populate这个第一个参数是一个对象,第二个参数是一个Map集合,Map集合的第一个参数是记录成员变量的,第二个是记录值的
作者: 渣.. 时间: 2018-5-12 21:49
柯威龙
反射是java虚拟机在运行的时候,对于任何一个类都能够调用他的任意一个方法.
反射主要的是有一个暴力反射 setAccessible(true)
字节码我也不知道没搞懂是什么 只知道有三种获取方式
1:对象名.getClass获取
2.类名.class
3.class.forName(包名.类名)
构造方法
Constructor<?>[] getConstructors():这个构造方法是获取类中的构造方法然后返回一个数组
Constructor<T> getConstructor(Class<?>... parameterTypes) :接受一个可变的参数,然后可以根据串进去的类型来判断使用的构造方法
成员方法,与成员变量应该就是获取成员方法的对象和值.
成员方法有根据方法名返回Method对象:Method getMethod(String name,class<>...parameterTypes)
根据指定的参数和方法名返回Method对象:Field getDeclaredField(String name)
获取所有的成员变量包含私有的:Field[] getDeclaredFields()
根据指定的参数,获取public修饰的字段:Field getField(String name)
javaBean就是用来封装数据的,让反射更简便
BeanUtils最常用的有三个方法,三个方法都是用static静态来修饰的:
static void setProperth(Object bean, String name, Object value)
Object bean:需要设置属性的对象
String name 需要修改的属性名称
Object value 需要修改的具体元素
static String getProperty(Object bean, String name)
Object bean 要获取的javaBean对象
String name 对象中的某个属性
static void populate(Object bean, Map properties)
Object bean 设置属性的对象
Map properties 将属性以Map集合的的形式传入
作者: chenyelong 时间: 2018-5-12 21:50
陈叶隆
我今天学到了字节码对象的使用.之前学过这三种获取字节码对象的方法,可是没有教过具体用来干嘛的,今天知道了,其实跟File file有点类似的功能,先创建这个对象,然后可以对这个对象进行一些具体的操作,对对象的理解更略懂了一点.而且方法也是get/set,跟之前学的一些类比如ArrayList,Date的成员方法也有点相似,我本人比较容易忽略的一点就是对非公有字段操作的时候老是忘调用setAccessible;我觉得以防万一,好的办法就是把每次获取都用 getDeclaredField,然后field.setAccessible记成一种格式,因为即使公有的用getDeclaredField也没关系.
作者: 铁木啊童臂 时间: 2018-5-12 21:50
汪志阳的反射总结:
学习反射可以通过Class类的方法直接获取字节码对象,然后创建(Student)这种类对象,调用构造方法,成员方法,成员变量,无论他们的修饰符是什么,顽固的采用暴力反射,让系统跳过检查,进行获取,然后进行增删查减的操作
javaBean就是我们之前创建的类,多了一步需要在类名点击"加锁",这样后续改变内容不影响程序运行,类似于类的地址值,字节码.
BeanUtil工具类,获取获取.populate的使用在于修改任意对象中的属性, 为传入Map集合中的键和值,自定义工具有点乱,在看着注释步骤能写出,独立写思路不够清晰,想到什么写什么,还需要慢慢思索,多敲几遍.
作者: 偏离X 时间: 2018-5-12 21:52
郭明杰:反射:
通过反射,可以实现对一个类私有方法,变量的操作
有三种方式可以获取类的字节码对象,
1:通过对象名.getClass()获取
2:通过类名.class 直接获取
3:通过全类名获取,比较常用 Class.forName(“包名+类名”)
Class中获取有参构造的方法是getConstructor,获取无参构造用newInstance()方法快速创建
对类中私有的属性进行操作时,必须要关闭java的访问(setAccessible(true))
BeanUtils工具类 底层采用反射,需要掌握的方法:
populate(Object bean,Map map)
需要捕获异常
作者: 滴滴eclipse启动 时间: 2018-5-12 21:53
江某人(总结)
阐述什么事反射机制:
反射机制是一门很强大的功能 可以获取private修饰了的方法和属性
阐述什么是字节码对象、以及获取的三种方式:
字节码对象是唯一的,获取方式有
1.对象名.getCalss();
2. 类名.class
3. Class.forName(放一个类的包名和类名);
阐述JavaBean的作用:
是一门很强大的工具类 创建对象就可以各种赋值 吊的不行 setProperty 可以赋值 getProperty可以读取 Populate这个是最强的
独立使用BeanUtils工具类:
学会使用BeanUtils中的三个方法
作者: 磬辰 时间: 2018-5-12 21:53
本帖最后由 磬辰 于 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的实例，我们需要从中取得某个属性，设定某个属性的值.当然有兴趣就可以去研究.
作者: Yanmo_ 时间: 2018-5-12 21:54
颜琳琳
一.反射:获取类对象(Class对象).
作用:运行时,获取类对象成员,调用成员.
二. 主要是通过创建该类的字节码对象再来创建该类的对象
Class.forname(全类名)方法创建字节码对象,
另外还有: 类名.class 对象名.getclass
newInstance方法来创建该类的对象(通过空参),主要的方法
主要方法有:
getConstructors()可以查看所有的构造方法
getConstructor()括号带参数时,使用数据类型.class
通过 带有Declared的方法都是可以访问被私有修饰的方法
Field 是获取成员变量时返回的值, 有get和set方法
Invoke( 方法名,参数 )调用成员方法的方法 参数根据方法来定
注意:
通过反射获取的私有变量或者私有方法,都要用setAccessible()方法让JVM不检查.
三.JavaBean:
作用:用来封装数据,和普通的类多了生成一个序列号.
BeanUitls重要的方法:
Static void Populate(Object bean,Map map) 给对象查看和修改对象中的属性
注意:
在测试类中用Map集合添加的元素在对应的类中找不到相同的元素,所有需要捕获异常.
作者: it小白001 时间: 2018-5-12 21:55
吴俊斌
1,什么是反射?反射就是在运行时,可以获取或改变成员和属性的机制
2,字节码的三种获取方式:
类名. class 对象名.getClass Class.forName(包名加类名)
通过获取的构造创建对
先获取字节码对象,调用getConstructor()方法,如果创建有参的的
构造,参数是类型的字节码对象.
快捷生成的构造方法创建对象的方法是 字节码对象调用newInstance()方法,
这方法只能创建空参的
3,获取成员变量(字段)
字节码对象调用getField()方法,这个只能获取public修饰的成员变量,使用有参
的传递的是字符串.返回的是一个FIled对象,可以用调用get 和set获取和设置变量
字节码对象调用 getDeclaredFields()方法,可以获取所有成员变量,使用有参传递
的是字节码对象,返回的也是一个Filed对象,在使用前面要调用setAccessible(true)让jvm不检查,然后再调用setPropert和getPropert获取和设置
4获取成员变量
字节码对象调用getMethod方法获取public修饰的Method对象,使用有参构造传递的是参数的字节码对象,可以调用invoke()将方法运行
字节码对象调用getDeclaredMethod方法获取所有的method对象,使用方式一样
5,JavaBean格式:
类使用公共进行修饰
供私有修饰的成员变量
为成员变量提供公共getter和setter方法
提供公共无参的构造
添加实现序列号接口(就是实现Serializable,再加一个序列号)
6,BeanUtils就是一个工具类,用类名调用setProperty对象中public修饰的属性赋值.调用getProperty可以获取对象中public修饰的属性,调用populate可以获取对象中所有的属性赋值
作者: 渣.. 时间: 2018-5-12 21:56
柯威龙
反射是java虚拟机在运行的时候,对于任何一个类都能够调用他的任意一个方法.
反射主要的是有一个暴力反射 setAccessible(true)
字节码我也不知道没搞懂是什么 只知道有三种获取方式
1:对象名.getClass获取
2.类名.class
3.class.forName(包名.类名)
构造方法
Constructor<?>[] getConstructors():这个构造方法是获取类中的构造方法然后返回一个数组
Constructor<T> getConstructor(Class<?>... parameterTypes) :接受一个可变的参数,然后可以根据串进去的类型来判断使用的构造方法
成员方法,与成员变量应该就是获取成员方法的对象和值.
成员方法有根据方法名返回Method对象:Method getMethod(String name,class<>...parameterTypes)
根据指定的参数和方法名返回Method对象:Field getDeclaredField(String name)
获取所有的成员变量包含私有的:Field[] getDeclaredFields()
根据指定的参数,获取public修饰的字段:Field getField(String name)
javaBean就是用来封装数据的,让反射更简便
BeanUtils最常用的有三个方法,三个方法都是用static静态来修饰的:
static void setProperth(Object bean, String name, Object value)
Object bean:需要设置属性的对象
String name 需要修改的属性名称
Object value 需要修改的具体元素
static String getProperty(Object bean, String name)
Object bean 要获取的javaBean对象
String name 对象中的某个属性
static void populate(Object bean, Map properties)
Object bean 设置属性的对象
Map properties 将属性以Map集合的的形式传入
作者: 厦门黑马王子 时间: 2018-5-12 21:57
郑雪平
今天学习了反射这个知识点,知道了原来反射挺好用的,它在运行时可以使用暴力手段调用任何类并获取所有属性和方法,我们想知道的字节码里的所有信息,在只知道类名的情况下就能调取字节码对象,而且还可以通过三种方法获取.
使用f.setAccessible(true)开关可以免检查,用JavaBean进行数据封装,可以简化代码流程,使用起来方便了许多.
作者: Nevermo 时间: 2018-5-12 21:58
许煜
每日总结
反射:通过字节码文件完成对数据的处理
优点:可做到无视权限
缺点:数据类型精度有所损失,如int降为string ,string 降为object
利用反射实现处理数据过程
1.获取类的字节码对象(01getclass 02class.forname 03.class)
2.获取构造方法对象 constuctor ,再用newinstance方法创建object对象(此时数据类型精度下降,因为无法直接创建类对象接收newinstance) 带参创建newinstance(xxx.class...)
3.通过字节码对象获取public成员变量 field getfield(string) 私有及所有使用field getdeclaredfiled(string) 成员变量有object get(object,”name”) void set(object,value)两种方法 私有成员需设置filed.setaccessable权限为true
4.通过字节码对象获取public方法method getmethod(“name”,带参的话加上餐数类型.class)
通过字节码对象获取私有及所有方法method getdeclaredmethod(“name”,带参的话加上餐数类型.class) 私有方法需设置method. setaccessable为true 通过method.invoke(参数或不带参数)调用方法
Java bean 规范 私有成员变量 public成员方法 继承系列化接口并随机生成序列号
BeanUtils 3个静态方法 setproperty(bean,string ,object)用于设置成员变量
Getproperty(bean ,string)用于获取成员变量 polulate(bean,map)也是用于设置成员变量
作者: 郁闷客 时间: 2018-5-12 21:58
反射总结-------林树德
今天学习了反射,反射可以通过暴力方法获取对象的成员变量及构造方法,及大提高了以前通过对象来获取方法的效率,字节码对象可以通过类名.class,对象名.get.Class()及Class.forName(“com.itheima_01.Student”)来货取;beanutils可以很方便的提高我们的开发效率.需要通过导包才能获取其中方法;
作者: cxming 时间: 2018-5-12 21:58
陈旭明
上午学习了创建对象的另外一种方式,然后可以通过对该对象的反射操作获
取非public修饰的成员(包括成员变量和成员方法),并能对成员进行一系列操作
(主要是对成员进行获取和赋值)。非public(private、protect、 )修饰的成员
优先考虑用反射。下午学习了Beanutils的三种方法:BeanUtils.getProperty、
BeanUtils.setProperty、BeanUtils.populate,前面两种作为了解,重点掌握
BeanUtils.populate方法就好,该方法主要是运用HashMap,然后对成员变量
进行赋值,底层也是通过反射的原理实现的。
作者: 渣.. 时间: 2018-5-12 22:00
柯威龙
反射是java虚拟机在运行的时候,对于任何一个类都能够调用他的任意一个方法.
反射主要的是有一个暴力反射 setAccessible(true)
字节码我也不知道没搞懂是什么 只知道有三种获取方式
1:对象名.getClass获取
2.类名.class
3.class.forName(包名.类名)
构造方法
Constructor<?>[] getConstructors():这个构造方法是获取类中的构造方法然后返回一个数组
Constructor<T> getConstructor(Class<?>... parameterTypes) :接受一个可变的参数,然后可以根据串进去的类型来判断使用的构造方法
成员方法,与成员变量应该就是获取成员方法的对象和值.
成员方法有根据方法名返回Method对象:Method getMethod(String name,class<>...parameterTypes)
根据指定的参数和方法名返回Method对象:Field getDeclaredField(String name)
获取所有的成员变量包含私有的:Field[] getDeclaredFields()
根据指定的参数,获取public修饰的字段:Field getField(String name)
javaBean就是用来封装数据的,让反射更简便
BeanUtils最常用的有三个方法,三个方法都是用static静态来修饰的:
static void setProperth(Object bean, String name, Object value)
Object bean:需要设置属性的对象
String name 需要修改的属性名称
Object value 需要修改的具体元素
static String getProperty(Object bean, String name)
Object bean 要获取的javaBean对象
String name 对象中的某个属性
static void populate(Object bean, Map properties)
Object bean 设置属性的对象
Map properties 将属性以Map集合的的形式传入
作者: wpwing 时间: 2018-5-12 22:01
吴鹏
字节码对象获得的方式有三种
新建对象后用getClass()方法;用类名.class;还有通过Class.forName(全类名)获得,推荐使用最后一个;
例如:
Class clazz = Class.forName("com.itheima.Student");
通过clazz可以直接调用无参构造,而不必通过Constructor,例如:
Object stu = clazz.newInstance();
------------------------------------------------------------------
通过反射获取构造方法,成员变量跟成员方法中要注意的几个点:
1 在使用getConstructor() 获得构造时,若括号里面没放入任何参数,则获得的是无参构造,在创建对象时,newInstcnce()里面也不能放入任何内容,
对象创建好后里面的数值是默认数值;如果获得的是有参构造,则括号里面必须填入类里面传参的字节码对象,创建对象时也必须传入参数;
2 获取private修饰的成员变量时,设置元素时必须先调用setAccessible(true)方法,开启访问权限;
3 获取方法时,若获取的方法无传参,则getMethod()或getDeclaredMethod()方法里面只需写入方法名,若
获取的方法有传参,则必须写入传参的字节码对象,如getDeclaraedMethod("method",String.class,int.class);
4 调用方法的时候,
若调用的方法无传参,无返回值,则括号里面不需任何内容;
若调用的方法有传参,无返回值,则括号里面必须有相对应的参数;
若调用的方法无传参,有返回值,则需要用一个变量接收返回值;
若调用的方法有传参,有返回值,则括号里面必须有对应的参数,且必须有变量接收返回值;
---------------------------------------------------------------------
JavaBean和BeanUtils相关:
创建一个JavaBean标准的类,要做到:
类使用public修饰;
提供private修饰的成员变量;
为成员变量提供setter和getter方法;
提供public修饰的无参构造;
实现Serializable(实现序列号化);
导入外面的包,可以在项目下面建立一个lib文件夹,把包都丢进去,然后导入,哪个项目要用,哪个项目就要导入;
BeanUtils三个常用的方法,主要记住static void populate(Object bean, Map properties) 这个方法,
如果map用的熟练,可以把static void setProperty(Object bean, String name, Object value)这个拿出来溜溜;
static void populate(Object bean, Map properties)方法里:
map集合里面的键就对应对象里面的变量,键的值就对应变量的值,
所以可以通过把要设置的值先put到map里面,然后通过populate添加,还可以自动帮我们去除在对象里面不存在的变量;
如果要自己重写populate,
用map的keySet()方法获得键后,遍历这个set集合,然后根据每个键(相当于变量名,但是要通过toString转换成字符串),获得
获得对象中的变量,然后用键获得map中对应的值,写进对象中对应变量名,注意打开权限开关(setAccessible(true));
当然,还要判断map这个键在对象中是否存在.
作者: Do1 时间: 2018-5-12 22:01
本帖最后由 Do1 于 2018-5-13 00:52 编辑
郑泽珑
一、反射
1.反射可以通过class字节码使用Constructor类来创建目标的公私有对象
2.通过使用Field Method 这2个类的方法来调用,设置公私有成员变量及方法
3.Constructor,Field,Method 调用设置公私有变量,方法时 方法get后加上DeclaredField 可以获取私有的变量及方法
(暴力反射)
我们使用反射可以使类的调用更加灵活
反射三步骤:
1.获取Class字节码
2.创建Constructor类对象接收公私有参无参构造
3.创建Object对象接收Constructor创建的公私有参无参构造;
暴力反射在get后加上DeclaredField 且将setAccessible设为true 跳过检查
有参构造传入的参数是基本数据类型的.class形式 如:Constructor c=clazz.getConstructor(String.class,String.class);
无参构造不需要传入参数
二、JavaBean
JavaBean是一个带有序列号的普通类
JavaBean通过序列号确定指定的类,使用BeanUtils设置类的公私有成员变量值
BeanUtils学习了3种基本方法分别是:
static void populate(Object bean, Map properties)
static String getProperty(Object bean, String name)
static void setProperty(Object bean, String name, Object value)
通过这3个方法可以直接给公私有成员变量赋值
通过自己写BeanUtils了解到了set get方法的重写,用到的是反射
作者: 沅瞻 时间: 2018-5-12 22:03
詹源
学习反射后,获取调用成员的行为变得更加快捷和灵活;
反射的面向对象性更强;反射较依赖字节码对象来完成操作;
BaanUtils工具类更加方便的对对象属性进行获取,修改,赋值.
作者: 376091692 时间: 2018-5-12 22:22
凌辉：
总结:
今天学习了反射
反射获取类的对象,等于一个人去解剖,拿里面的所有东西去用;
有时候会遇到不能修改类的情况,直接通过反射就可以解决了;
还学习了封装数据的JavaBean,通过BeanUtils简化操作
作者: 名字被人注册了 时间: 2018-5-12 22:24
刘文峰:
反射
1.反射的作用:在程序运行时可以调用类的所有成员(变量,方法,包括私有的)
2.反射的前提是字节码对象,获取类的字节码对象有三种方法
对象名.getClass()方法
类名.class属性
Class.forName()方法
3.方法:
A: 字节码对象.getConstrctor():获取字节码对象描述类public修饰的构造方法.根据括号里的参数获取对应的有参/无参Constructor对象,参数为成员属性的数据类型.class(例:getConstrctor(String.class))
字节码对象.getConstrctors():获取字节码对象描述类的所有public修饰的构造方法,存储到一个Constrctors数组里.
B: getField(String name):获取类里的public修饰的成员变量名的Field对象,参数为成员变量名的字符串模式(例:public int age; getField(“age”))
getFields():获取一个包含public修饰的成员变量的 Field 对象的数组;
C: getMethod(Stringname,Class<?>... parameterTypes):获取类里的指定方法的Method对象;参数为方法名的字符串形式(可以追加参数:数据类型.class)
invoke();可以实现Method对象获取到的方法,传入类的对象
D:上面的 方法在get后面加declare可以获得被私有的成员变量,方法和构造(getDeclareField());
BeanUtils
setProperty(对象名,要修改的变量名的字符串形式,修改后的值):可以用来修改指定成员变量
getProperty(对象名,要获取的变量名的字符串形式):可以获取指定成员变量的值
Populate(对象名,map集合):将类里的成员变量名作为键存入map集合中,通过遍历集合然后筛选为成员变量赋值
作者: 376091692 时间: 2018-5-12 22:27
凌辉：
总结:
今天学习了反射
反射获取类的对象,等于一个人去解剖,拿里面的所有东西去用;
有时候会遇到不能修改类的情况,直接通过反射就可以解决了;
还学习了封装数据的JavaBean,通过BeanUtils简化操作
作者: q55w66 时间: 2018-5-12 22:28
反射：在程序运行时，获取一个对象的所有信息，将其储存到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的区别
作者: Eclipse启动 时间: 2018-5-12 22:41
郑阳阳
反射学完后获取对象变得很简单 只需要有对象的字节码就可以.
获取字节码对象的三种方式:
(1)对象.getclass()
(2)类名.Class
(3)Class.forName(全类名)
通过调用Class的方法可以获取对象的public修饰的构造getConstructor(加了s获取所有构造),可以获取public修饰的字段对象Field getField
(加了s获取所有字段),还可以调用对象的方法getMethod,前面的方法中间加了Declared可以获取被私有的构造,变量和方法,也是暴力访问的前提.
setAccessible这个是暴力访问的开关,参数为true,取消java访问检查,开了之后就和开挂了一样可以为所
欲为随便获取和修改变量和方法.
BeanUtils有三个方法可以给对象的成员变量赋值和获取成员变量的值,最好用的是populate可以配合Map集合使用
作者: hpb199567 时间: 2018-5-12 22:50
反射总结
何平波
2018-05-12-星期六
一.反射是什么呢?
1.概念 Java反射就是在运行状态中,对任意的一个类,都能知道这个类的属性(字段)和方法.
就是对于任意一个对象,都能够调用它的任意一个方法
这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制.
2.自我理解:反射在对象类中的使用可以灵活的获取到对象类中的变量,构造方法(无参,有参)和方法,最大的优点是可以灵活的修改成员变量信息,可以任意调用方法(无论是有返回值还是没有返回值的,方法中是有参的还是无参的都可以快速灵活的获取到).
二.反射(字节码)有三种获取方法格式需要自己去理解,记忆.
对象名.getCalss(); 类名.class Class.forName(“包名.类名”);
三.反射中的操作构造方法、成员方法、成员属性分别可以分文两类
构造方法:newInstance()方法, 只能通过空参的构造方法创建对象
一类是获取的公共的(public修饰的)构造方法、成员方法、成员属性,这时候的获取方法会比较易于理解
二类是获取的私有的(private修饰的)构造方法、成员方法、成员属性,这时候就需要通过
getDeclaredField(“name”) + setAccessible(true)来让反射暴力获取和让jvm跳过检查;
重要的一点是:无论获取.修改.构造方法、成员方法、成员属性中的信息都有很多的构造方法,需要去理解,记忆.
四.以前编写学生类就叫学生类,现在可以用更专业的英文Javabean来写,辛亏今天知道了Javabean是一个标准的类(学生类),不然以后老板叫我写一个javabean,我就懵了.
五.有一个工具包BeanUtils,而这个BeanUtils却是一个叫做Apache的组织编写.
那么这个组织编写的代码当中, 有一个系列可以很方便的提高我们今后的开发效率.这个系列为Commons, BeanUtils就是其中之一. 在这里需要了解这个包BeanUtils的功能和作用
这个包下有3个功能比较常用
getProperty 用来给对象中的属性赋值
参数1: 需要设置属性的对象
参数2: 需要修改的属性名称
参数3: 需要修改的具体元素
getProperty 用来获取对象中的属性
参数1: 要获取的javaBean对象
参数2: 对象中的哪个属性
Populate 用来给对象中的属性赋值(掌握)
参数1: 要设置属性的对象
参数2: 将属性以Map集合的形式传入
Key : 属性的名称
Value: 属性具体的值
BeanUtils工具包可以与HashMap集合相结合使用,之前的hashMap集合如果要获取元素,有两种方式,分别是keySet() 和entrySet(),现在多了BeanUtils工具包可以直接使用BeanUtils.populate(类名,集合名)来直接获得,这样更加的方便
作者: hpb199567 时间: 2018-5-12 22:54
反射总结
何平波
2018-05-12-星期六
一.反射是什么呢?
1.概念 Java反射就是在运行状态中,对任意的一个类,都能知道这个类的属性(字段)和方法.
就是对于任意一个对象,都能够调用它的任意一个方法
这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制.
2.自我理解:反射在对象类中的使用可以灵活的获取到对象类中的变量,构造方法(无参,有参)和方法,最大的优点是可以灵活的修改成员变量信息,可以任意调用方法(无论是有返回值还是没有返回值的,方法中是有参的还是无参的都可以快速灵活的获取到).
二.反射(字节码)有三种获取方法格式需要自己去理解,记忆.
对象名.getCalss(); 类名.class Class.forName(“包名.类名”);
三.反射中的操作构造方法、成员方法、成员属性分别可以分文两类
构造方法:newInstance()方法, 只能通过空参的构造方法创建对象
一类是获取的公共的(public修饰的)构造方法、成员方法、成员属性,这时候的获取方法会比较易于理解
二类是获取的私有的(private修饰的)构造方法、成员方法、成员属性,这时候就需要通过
getDeclaredField(“name”) + setAccessible(true)来让反射暴力获取和让jvm跳过检查;
重要的一点是:无论获取.修改.构造方法、成员方法、成员属性中的信息都有很多的构造方法,需要去理解,记忆.
四.以前编写学生类就叫学生类,现在可以用更专业的英文Javabean来写,辛亏今天知道了Javabean是一个标准的类(学生类),不然以后老板叫我写一个javabean,我就懵了.
五.有一个工具包BeanUtils,而这个BeanUtils却是一个叫做Apache的组织编写.
那么这个组织编写的代码当中, 有一个系列可以很方便的提高我们今后的开发效率.这个系列为Commons, BeanUtils就是其中之一. 在这里需要了解这个包BeanUtils的功能和作用
这个包下有3个功能比较常用
getProperty 用来给对象中的属性赋值
参数1: 需要设置属性的对象
参数2: 需要修改的属性名称
参数3: 需要修改的具体元素
getProperty 用来获取对象中的属性
参数1: 要获取的javaBean对象
参数2: 对象中的哪个属性
Populate 用来给对象中的属性赋值(掌握)
参数1: 要设置属性的对象
参数2: 将属性以Map集合的形式传入
Key : 属性的名称
Value: 属性具体的值
BeanUtils工具包可以与HashMap集合相结合使用,之前的hashMap集合如果要获取元素,有两种方式,分别是keySet() 和entrySet(),现在多了BeanUtils工具包可以直接使用BeanUtils.populate(类名,集合名)来直接获得,这样更加的方便
作者: 郑学馨 时间: 2018-5-12 23:04
郑学馨
1:知识重点一:
1.1反射:可以直接访问类中的成员方法和成员变量,(主要是"暴力反射",可以用来修改类中的私有成员变量和成员方法)
1.2反射运用步骤:第一步:获取类的字节码对象(三种获取方法:class.forname("全包名"),类的对象名.getclass,类名.class)
第二步:创建类的对象;分为创建有参对象,和创建无参对象;
1.2.1:创建有参对象:(比较麻烦)需要利用getconstructor()获取类中的有参构造方法,创建该方法的对象,利用对象名.newinstance("","")来创建一个有参对象;
1.2.2:创建无参对象:(比较简单,常用),直接类的字节码对象.newinstance();就可以创建.
第三步:无参构造设置成员变量;使用到(对象名.getfield(成员变量名))创建一个类中的成员变量对象,在调用该对象中的set(类的对象,要给成员变量赋的值)来给成员变量赋值;
重要点:当访问到类中的私有成员变量时,要打开反射机制忽略机制,也就是:setAccessible(true);//设置反射时取消Java的访问检查,暴力访问!这样就能对私有的成员变量进行修改
,私有的成员方法同样适用!
知识重点二:
2.1:javabean:类中实现Serializable接口,重写接口中的方法,获取一个固定的id值;(将类封装成一个整体??)
2.2:beanUtils工具类的使用,直接beanUtils.方法名(今天主要学到的方法有:1:setProperty(Object bean, String name, Object value)// 给JavaBean对象的成员变量进行赋值)
2:getProperty(Object bean, String name) // 获取JavaBean对象的成员变量的值 3:populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
重点(使用该工具类,首先也要像是用使用反射一样步骤,
创建类的字节码对象---创建类的对象---通过beanutils给对象赋值)对比反射的赋值方式简单化很多,推荐使用,
作者: sts 时间: 2018-5-12 23:09
苏海斌
反射就是在运行状态中,能够获取任意一个类的所有对象和方法,包括私有的
字节码对象获取的三种方式
对象名+getclass()
类名+class
Class+forname()
获取构造方法
Conscructor快捷键生成
获取成员方法
Getmethod()
暴力反射
Setac快捷键
获取成员变量
公共
getFileds()
所有的包括私有
getDe快捷键生成
使用BeanUtils工具类
Static void setProperty(Object bean,String name,Object value)赋值
Static String getProperty(Object bean,String name)获取
Static String void populate(Object bean,map properties)赋值
作者: it小白001 时间: 2018-5-12 23:17
1,什么是反射?反射就是在运行时,可以获取或改变成员和属性的机制
2,字节码的三种获取方式:
类名. class 对象名.getClass Class.forName(包名加类名)
通过获取的构造创建对
先获取字节码对象,调用getConstructor()方法,如果创建有参的的
构造,参数是类型的字节码对象.
快捷生成的构造方法创建对象的方法是 字节码对象调用newInstance()方法,
这方法只能创建空参的
3,获取成员变量(字段)
字节码对象调用getField()方法,这个只能获取public修饰的成员变量,使用有参
的传递的是字符串.返回的是一个FIled对象,可以用调用get 和set获取和设置变量
字节码对象调用 getDeclaredFields()方法,可以获取所有成员变量,使用有参传递
的是字节码对象,返回的也是一个Filed对象,在使用前面要调用setAccessible(true)让jvm不检查,然后再调用setPropert和getPropert获取和设置
4获取成员变量
字节码对象调用getMethod方法获取public修饰的Method对象,使用有参构造传递的是参数的字节码对象,可以调用invoke()将方法运行
字节码对象调用getDeclaredMethod方法获取所有的method对象,使用方式一样
5,JavaBean格式:
类使用公共进行修饰
供私有修饰的成员变量
为成员变量提供公共getter和setter方法
提供公共无参的构造
添加实现序列号接口(就是实现Serializable,再加一个序列号)
6,BeanUtils就是一个工具类,用类名调用setProperty对象中public修饰的属性赋值.调用getProperty可以获取对象中public修饰的属性,调用populate可以获取对象中所有的属性赋值q
作者: it小白001 时间: 2018-5-12 23:19
吴俊斌
1,什么是反射?反射就是在运行时,可以获取或改变成员和属性的机制
2,字节码的三种获取方式:
类名. class 对象名.getClass Class.forName(包名加类名)
通过获取的构造创建对
先获取字节码对象,调用getConstructor()方法,如果创建有参的的
构造,参数是类型的字节码对象.
快捷生成的构造方法创建对象的方法是 字节码对象调用newInstance()方法,
这方法只能创建空参的
3,获取成员变量(字段)
字节码对象调用getField()方法,这个只能获取public修饰的成员变量,使用有参
的传递的是字符串.返回的是一个FIled对象,可以用调用get 和set获取和设置变量
字节码对象调用 getDeclaredFields()方法,可以获取所有成员变量,使用有参传递
的是字节码对象,返回的也是一个Filed对象,在使用前面要调用setAccessible(true)让jvm不检查,然后再调用setPropert和getPropert获取和设置
4获取成员变量
字节码对象调用getMethod方法获取public修饰的Method对象,使用有参构造传递的是参数的字节码对象,可以调用invoke()将方法运行
字节码对象调用getDeclaredMethod方法获取所有的method对象,使用方式一样
5,JavaBean格式:
类使用公共进行修饰
供私有修饰的成员变量
为成员变量提供公共getter和setter方法
提供公共无参的构造
添加实现序列号接口(就是实现Serializable,再加一个序列号)
6,BeanUtils就是一个工具类,用类名调用setProperty对象中public修饰的属性赋值.调用getProperty可以获取对象中public修饰的属性,调用populate可以获取对象中所有的属性赋值
作者: 黄志彬 时间: 2018-5-12 23:21
黄志彬
反射在运行时我们可以获取任意一个类的所有方法和属性，可以调用任何一个类的方法和属性，包含私有成员。
反射的前提：获取字节码对象（Class）
获取字节码对象的方式有三种
1通过object的getClass方法 必须要有对象
2通过类名获取字节码对象 需要有类名
3Class里面的一个静态方法 forName(String className) 需要全类名 更为灵活，推荐使用
通过反射获取构造方法
Class.getConstructors() 返回所有public修饰的构造方法，以数组的方式返回
Class.getConstructor() 获取无参构造 只能获取某一个构造
Class.getConstructor() 获取有参构造 数据类型要跟成员匹配
newInstance()创建对象的快捷方法 只能通过空参的构造方法创建对象
setAccessible(true);调用该方法可以忽略JVM的检查
BeanUtils 简化javaBean封装数据的操作。
BeanUtils的setProperty和getProperty方法底层不是直接操作成员变量，而是操作和变量名有关的get，set方法
static void populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
作者: 渣.. 时间: 2018-5-12 23:23
柯威龙
反射是java虚拟机在运行的时候,对于任何一个类都能够调用他的任意一个方法.
反射主要的是有一个暴力反射 setAccessible(true)
字节码我也不知道没搞懂是什么 只知道有三种获取方式
1:对象名.getClass获取
2.类名.class
3.class.forName(包名.类名)
构造方法
Constructor<?>[] getConstructors():这个构造方法是获取类中的构造方法然后返回一个数组
Constructor<T> getConstructor(Class<?>... parameterTypes) :接受一个可变的参数,然后可以根据串进去的类型来判断使用的构造方法
成员方法,与成员变量应该就是获取成员方法的对象和值.
成员方法有根据方法名返回Method对象:Method getMethod(String name,class<>...parameterTypes)
根据指定的参数和方法名返回Method对象:Field getDeclaredField(String name)
获取所有的成员变量包含私有的:Field[] getDeclaredFields()
根据指定的参数,获取public修饰的字段:Field getField(String name)
javaBean就是用来封装数据的,让反射更简便
BeanUtils最常用的有三个方法,三个方法都是用static静态来修饰的:
static void setProperth(Object bean, String name, Object value)
Object bean:需要设置属性的对象
String name 需要修改的属性名称
Object value 需要修改的具体元素
static String getProperty(Object bean, String name)
Object bean 要获取的javaBean对象
String name 对象中的某个属性
static void populate(Object bean, Map properties)
Object bean 设置属性的对象
Map properties 将属性以Map集合的的形式传入
作者: zzx835387607 时间: 2018-5-12 23:33
郑志祥
1.【理解】阐述什么是反射机制
答;可以通过反射获取所有的构造方法与成员变量,成员方法
【应用】阐述什么是字节码对象、以及获取的三种方式
答; 1.Class clazz = s.getClass(); 对象.getClass()
2.Class clazz2 = Student.class; 类名.class;
3.forName(String className) (包名加类名,也叫全类名)
【应用】通过反射操作构造方法、成员方法、成员属性
字节码对象.getConstructor() 是用来获取构造方法的
1.无参数 Constructor c= 字节码对象.getConstructor()
2.有参 Constructor c= 字节码对象.getConstructor(参数类型.class,... )
3.无参与有参 Constructor[] cs = clazz.getConstructors();
4.//调用方法
Method m=clazz.getMethod("show1"); 如果方法里面的返回值 都用Object
将有参与无参都放在数组cs 在遍历数组(都是public 修饰,才可以访问)
【理解】阐述JavaBean的作用
答;只需要知道类名不用知道类里面的内容,就可以直接操作类里面的内容,多写或则少写,系统不会报错.
【应用】独立使用BeanUtils工具类
答;跟之前编写的学生类差不多.
【应用】独立编写MyBeanUitls工具类
答;跟之前测试不一样之处,
1.获取字节码对象(三种)
2.创建对象是用对象.newInstance()
3.创建集合,与集合联合使用
4.BeanUtils.populate(object, map); ,(对象,集合)
5.调用BeanUtils特有的方法
作者: 凉面要趁热吃 时间: 2018-5-12 23:36
黄进安:
字节码对象Class获取反射的对象:
1.直接通过字节码对象clazz.newInstance();获取无参构造方法(最为便捷的方式).
2.先通过class获取构造方法(有参无参取决于是否传入参数),再通过构造方法.newInstance();获取.
关于获取所有和获取指定对象:
eg: Field[] getFields() 与 Field getField(String name)
名词+s 在英语单词通常代表复数(多个)的意思;
所以无论的在获取反射的构造方法-成员变量-成员方法在获取所有与指定对象的区别在方法名都有直接的体现
获取私有的成员变量和成员方法甚至构造方法:
要记得设置反射时取消Java的访问检查,暴力访问,eg: filed.setAccessible(true); method. .setAccessible(true);
BeanUtils工具类的一些理解:
方法:BeanUtils.populate(要操作对象,map对象)
利用map对象的key的唯一性(每个成员变量也是唯一存在的)和key与value的一一对应关系(利用给定value的值给key,即成员变量赋值),简化了对对象元素的赋值操作
作者: 黄志彬 时间: 2018-5-12 23:38
黄志彬
反射在运行时我们可以获取任意一个类的所有方法和属性，可以调用任何一个类的方法和属性，包含私有成员。
反射的前提：获取字节码对象（Class）
获取字节码对象的方式有三种
1通过object的getClass方法 必须要有对象
2通过类名获取字节码对象 需要有类名
3Class里面的一个静态方法 forName(String className) 需要全类名 更为灵活，推荐使用
通过反射获取构造方法
Class.getConstructors() 返回所有public修饰的构造方法，以数组的方式返回
Class.getConstructor() 获取无参构造 只能获取某一个构造
Class.getConstructor() 获取有参构造 数据类型要跟成员匹配
newInstance()创建对象的快捷方法 只能通过空参的构造方法创建对象
setAccessible(true);调用该方法可以忽略JVM的检查
BeanUtils 简化javaBean封装数据的操作。
BeanUtils的setProperty和getProperty方法底层不是直接操作成员变量，而是操作和变量名有关的get，set方法
static void populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
作者: COLDER 时间: 2018-5-12 23:39
本帖最后由 COLDER 于 2018-10-18 19:08 编辑
一.什么是反射?
反射能否理解为是基于字节码文件进行的一种反编译操作(反编译工具)??也就是一种逆向的思维,通过字节码对象和方法的结合来获取字节码文件中的成员数据.
二.反射操作构造方法,成员变量,方法
反射对构造方法,成员变量,方法的操作是否可以理解为也是”增删改查”中修改与获取的另外一种形式表达?
操作步骤: 获取 --- 修改 --- 输出
注意点: 进行暴力反射需要设置访问权限,跳过JVM访问检查.void setAccessible(boolean flag)
三.JavaBean(封装数据)
JavaBean与创建对象类的区别:使用JavaBean需要实现序列号接口(Serializable),JavaBean无带参构造.
四.BeanUtils和myBeanUtils
BeanUtils可以理解为是使用别人已经编写好的工具包
MyBeanUtils可以理解为是对工具包底层的方法进行了解和根据自己的需求进行重新编写.
作者: ...ylq 时间: 2018-5-12 23:45
叶凌青
【理解】阐述什么是反射机制
反射:1.出现反射是因为后面框架的底层全部借助反射来完成,学习反射能让我们更好地对以后的内容进行理解
2.感觉就是为了强行获取字节码对象的成员
【应用】阐述什么是字节码对象、以及获取的三种方式
字节码对象,应该就是.class文件,
获取字节码对象的3种方式
1.对象.getClass
2.类名.class
3.class.forName("全类名")
【应用】通过反射操作构造方法、成员方法、成员属性
Field[] getDeclaredFields() //获取所有的成员变量 包含私有
Constructor c = clazz.getConstructor(String.class,int.class);//获取有参构造，参数1类型为String，参数2类型为int
Method getMethod(String name, Class<?>... parameterTypes)
【理解】阐述JavaBean的作用
感觉和普通类没什么区别,多实现了一个序列化接口
目的是为了让数据增加持久性,也就是说实现序列化接口的类是可以用对象流写入文件的
独立使用BeanUtils工具类
【应用】独立使用BeanUtils工具类
static void setProperty(Object bean, String name, Object value)// 给JavaBean对象的成员变量进行赋值
static String getProperty(Object bean, String name) // 获取JavaBean对象的成员变量的值
static void populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
作者: ...ylq 时间: 2018-5-12 23:48
叶凌青
【理解】阐述什么是反射机制
反射:1.出现反射是因为后面框架的底层全部借助反射来完成,学习反射能让我们更好地对以后的内容进行理解
2.感觉就是为了强行获取字节码对象的成员
【应用】阐述什么是字节码对象、以及获取的三种方式
字节码对象,应该就是.class文件,
获取字节码对象的3种方式
1.对象.getClass
2.类名.class
3.class.forName("全类名")
【应用】通过反射操作构造方法、成员方法、成员属性
Field[] getDeclaredFields() //获取所有的成员变量 包含私有
Constructor c = clazz.getConstructor(String.class,int.class);//获取有参构造，参数1类型为String，参数2类型为int
Method getMethod(String name, Class<?>... parameterTypes)
【理解】阐述JavaBean的作用
感觉和普通类没什么区别,多实现了一个序列化接口
目的是为了让数据增加持久性,也就是说实现序列化接口的类是可以用对象流写入文件的
独立使用BeanUtils工具类
【应用】独立使用BeanUtils工具类
static void setProperty(Object bean, String name, Object value)// 给JavaBean对象的成员变量进行赋值
static String getProperty(Object bean, String name) // 获取JavaBean对象的成员变量的值
static void populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
作者: 林荣彬 时间: 2018-5-12 23:54
林荣彬
反射机制就是当程序运行时,我们可以任意的调用一个对象的所有方法和属性
字节码获取有三总方式:
(1)通过对象名 .getclass() 在对象已经存在的情况下可以使用此方式,通过Object的getclass()方法获取
(2)通过类名 .class 只要知道类名就可以获取
(3)通过Class.forName(“全类名(包名+类名)”) 在不知道类名的情况下可获取
通过获取的对象创建对象:
(1)步骤;获得class对象-----获得构造-----通过构造获得实例化对象
(2)构造方法:
(1)Constructor<?>[] getConstructors() 获取该类中所有的构造方法, 返回的是一个数组
(2)Constructor<T> getConstructor(Class<?>... parameterTypes) 接受一个可变参数(可以传参数也可以不传), 可以根据传入的类型, 来匹配对应的构造方法
(3)快速的创建无参构造:Object obj = clazz.newInstance(); 是属于Class对象里面的不是Constructor里的
获取public成员变量:
(1)Field[] getFields() 获取所有公共的成员变量 返回对象数组
(2)Field getField(String name) 获取指定的成员变量 返回成员变量对象
获取private成员变量:
(1)Field[] getDeclaredFields() 暴力反射获取所有字段(包括私有) ,返回对象数组
(2)Field getDeclaredField(String name) 暴力反射获取所有字段(包括私有),返回成员变量对象
Field中的方法:
(1)Object get(Object obj) 通过对象获取成员变量的值
(2)void set(Object obj, Object value) 通过成员变量对象，修改为指定的值
(3)setAccessible(true) 设置反射时取消Java的访问检查,暴力访问
反射获取成员方法
Method getMethod(String name, Class<?>... parameterTypes) 可空参可无参
Method:
Object invoke(Object obj, Object... args) 可空参可无参
static void setProperty(Object bean, String name, Object value) 用来给对象中的属性赋值
static String getProperty(Object bean, String name) 用来获取对象中的属性
static void populate(Object bean, Map properties) 用来给对象中的属性赋值 属性是以Map集合的形式传入
注意：BeanUtils的setProperty和getProperty方法底层并不是直接操作成员变量，而是操作和成员变量名有关的get和set方法
作者: 小故事 时间: 2018-5-12 23:55
谢洪彬:
关键字: 反射 , BeanUtils
反射的作用: 不用创建类的对象,可以利用三种方法获取字节码对象从而创建类的对象
反射基本知识内容:
1.获取类中所有的构造方法
2.获取类中所有的成员变量
3.获取类中所有的成员方法
以上反射所用到的类基本都是Class中的,基本都是静态方法,直接类名调用
成员变量和成员方法也分public修饰的和非public修饰的
1.利用Class调用方法获取非public修饰的变量或方法,Class的方法名当中都含有Declared单词,
2.调用非public修饰的必须调用方法获取权限(也称暴力反射) 方法名:setAccessible(true)
BeanUtils
概念: 封装数据
重要方法: static void populate(Object bean, Map properties)
此方法主要是利用class字节码对象获取对应类的对象和Map集合一起进行操作.
作者: 1748341437 时间: 2018-5-12 23:56
今天在轩哥的认真教导下,我发现反射是一个很神奇的东西,他能非常暴力的访问到另一个类里的成员变量,成员方法,及构造方法;
还学习了字节码对象,知道了很多方法都需要调用字节码对象的方法来获取.
创建字节码对象有三种方式:
类名.class
Class.forName(全类名)
对象名.getClass()
反射操作构造方法、成员方法、成员属性有哪些?
所有方法都要用调用字节码对象的方法获取
Constructor c = clazz.getConstructor(String.class,int.class);//获取有参构造 Object obj = c.newInstance("lisi",30); 创建对象
Object obj = clazz.newInstance();//快速创建的无参构造
只能获取Public修饰的成员变量: Field[] getFields() //获取所有公共的成员变量 返回对象数组
Field getField(String name) 获取指定的成员变量 返回字段对象
只能获取private修饰的成员变量: Field[] getDeclaredFields() //获取所有的成员变量 包含私有
Field getDeclaredField(String name) //获取指定的成员变量 包含私有
获取pubic修饰的成员方法: Method getMethod(String name, Class<?>... parameterTypes)
获取private修饰的成员方法: Method m = clazz.getDeclaredMethod("setName", String.class) === m.setAccessible(true);开启暴力反射,就可以执行私有的方法了
你问我JavaBean的作用是什么?
那我就大发慈悲的告诉你吧:JavaBean就是用来封装数据的;
后来又学了BeanUtils工具类
它有三个方法:
setproperty(Object bean, String name, Object valeu)
getproperty(Object bean, String name)
populate(Object bean, Map properties)
虽然这三个方法我也不大会用,但是我还是知道第三个比较重要的,其他两个比较次一点.
最后的时候学了MyBeanUitls自定义工具类
.....在课上看到自定义类我是有点懵的,虽然说现在还是有点懵.但是好歹还是打下来了,哈哈.
作者: 1748341437 时间: 2018-5-12 23:58
林玮
今天在轩哥的认真教导下,我发现反射是一个很神奇的东西,他能非常暴力的访问到另一个类里的成员变量,成员方法,及构造方法;
还学习了字节码对象,知道了很多方法都需要调用字节码对象的方法来获取.
创建字节码对象有三种方式:
类名.class
Class.forName(全类名)
对象名.getClass()
反射操作构造方法、成员方法、成员属性有哪些?
所有方法都要用调用字节码对象的方法获取
Constructor c = clazz.getConstructor(String.class,int.class);//获取有参构造 Object obj = c.newInstance("lisi",30); 创建对象
Object obj = clazz.newInstance();//快速创建的无参构造
只能获取Public修饰的成员变量: Field[] getFields() //获取所有公共的成员变量 返回对象数组
Field getField(String name) 获取指定的成员变量 返回字段对象
只能获取private修饰的成员变量: Field[] getDeclaredFields() //获取所有的成员变量 包含私有
Field getDeclaredField(String name) //获取指定的成员变量 包含私有
获取pubic修饰的成员方法: Method getMethod(String name, Class<?>... parameterTypes)
获取private修饰的成员方法: Method m = clazz.getDeclaredMethod("setName", String.class) === m.setAccessible(true);开启暴力反射,就可以执行私有的方法了
你问我JavaBean的作用是什么?
那我就大发慈悲的告诉你吧:JavaBean就是用来封装数据的;
后来又学了BeanUtils工具类
它有三个方法:
setproperty(Object bean, String name, Object valeu)
getproperty(Object bean, String name)
populate(Object bean, Map properties)
虽然这三个方法我也不大会用,但是我还是知道第三个比较重要的,其他两个比较次一点.
最后的时候学了MyBeanUitls自定义工具类
.....在课上看到自定义类我是有点懵的,虽然说现在还是有点懵.但是好歹还是打下来了,哈哈.
作者: 小故事 时间: 2018-5-13 00:03
谢洪彬:
关键字: 反射 , BeanUtils
反射的作用: 不用创建类的对象,可以利用三种方法获取字节码对象从而创建类的对象
反射基本知识内容:
1.获取类中所有的构造方法
2.获取类中所有的成员变量
3.获取类中所有的成员方法
以上反射所用到的类基本都是Class中的,基本都是静态方法,直接类名调用
成员变量和成员方法也分public修饰的和非public修饰的
1.利用Class调用方法获取非public修饰的变量或方法,Class的方法名当中都含有Declared单词,
2.调用非public修饰的必须调用方法获取权限(也称暴力反射) 方法名:setAccessible(true)
BeanUtils
概念: 封装数据
重要方法: static void populate(Object bean, Map properties)
此方法主要是利用class字节码对象获取对应类的对象和Map集合一起进行操作.
作者: 黄兴磊 时间: 2018-5-13 00:09
反射
在运行时可以获得任何一个类的成员属性和方法,通过暴力反射可以获取类的私有成员;
首先要获取class对象,然后通过获取构造方法获取实例化对象
创建class对象有三种方式,:
1 通过已存在的对象名加上getclass
2通过类名点上class
3是通过class的静态方法 Class.forName 推荐使用这种方法,比较方便点
然后又学了getConstructor()
构造方法可以是有参构造,但实例化是一定要相互匹配上
getDeclaredField(Stringname) --> 暴力反射获取指定名称字段
记得要加dsetAccessible(boolean flag) --> 让jvm不检查权限 不然就获取不到私有的
作者: AsusCoder 时间: 2018-5-13 00:17
弄了一小时登录终于浮上来了。
姓名:曾耀峰
今天学的反射真是颠覆三观，通过反射可以获取任意一个类的所有方法和属性，面向对象的引以为傲的三大特征之一是封装。然而在反射面前却毫无反击之力。之前安卓的开发，就有提取过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工具类。通过反射能够很容易地写出来
听说总结不用贴代码。
作者: AsusCoder 时间: 2018-5-13 00:18
本帖最后由 AsusCoder 于 2018-5-13 00:21 编辑
发了两个楼。发了两个楼。发了两个楼。发了两个楼。
作者: 追风筝的人哇 时间: 2018-5-13 00:22
康元中
今天学习反射,反射是一种可以动态访问一个类的成员和构造.
第一个重点 掌握如何去访问一个类的构造/方法和变量
都是通过创建字节码对象 然后通过字节码对象调用一些方法 返回到相对应的字段/ 构造/method
然后要掌握以下的一些方法和类似的区别
1 getConstructor(String.class,int.class);//获取有参构造，参数1类型为String，参数2类型为int
Object obj = c.newInstance("lisi",30); 创建对 象
2 Field getField(String name) 获取指定的成员变量 返回字段对象
Field getDeclaredField(String name) //获取指定的成员变量 包含私有
3 Method m = clazz.getDeclaredMethod("setName", String.class)
Object invoke(Object obj, Object... args)
注意 访问私有的变量和成员时要暴力反射 开启setAccessible(true)
第二个重点是 学习Beanutil 这个工具类里面的一些方法 setProperty getProperty 和populate (bean,map)这个方法重要
javabean(标准书写规范)
作者: lnongge 时间: 2018-5-13 00:37
16lws
今天学习了反射,反射是java中提供的另一种获取构造方法,成员的暴力机制,它把,构造方法,成员变量,成员方法各自封装成一个独立的类,通过这些封装的类的对象可以对构造方法,成员变量,成员方法进行操作.还学习了使用BeanUtils来封装数据,并自己实现Beanutils功能.具体如图
-
360截图20180512231348099.jpg
(31.34 KB, 下载次数: 28)
反射
作者: 丶犯二 时间: 2018-5-13 00:56
任佳锋
JAVA反射机制
是指程序运行过程时，通过字节码对象与方法的配合,对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；
三种字节码对象的获取方式
通过类名直接获取字节码对象 譬如Student.class
创建对象 ,通过对象调用getclass方法获取
通过Class类直接调用forname方法传入全类名参数获取
反射获取构造方法的两种方式
通过字节码对象调用 getconstrucotor 方法在括号内传入参数类型.class获取有参构造方法
Constructor con = clazz.getConstructor(String.class, int.class);
再通过newInstance创建对象并传入参数;
Object obj = con.newInstance("老陈", 47);
获取空参构造方法
Constructor cstr = clazz.getConstructor();
通过newInstance创建对象;
Object ni = cstr.newInstance();
其次 反射获取成员变量(字段)与成员方法的方法大致分为两种:
一种是获取public修饰的也就是公共的成员变量(字段)与方法:
Field[] getFields() 获取所有公共的成员变量(字段) 返回对象数组
Field getField(String name) 获取指定的成员变量(字段) 返回成员变量(字段)的对象
获取public成员方法:
Method getMethod(String name,(方法名) Class<?>... parameterTypes(当方法需要传入参数时此处填写传入参数的类型.class))
Object invoke(Object obj, Object... args) 获取之后通过此方法执行获取的成员方法
二种是获取私有的成员变量(字段)与方法:
Field[] getDeclaredFields() 获取所有的成员变量 包含私有
Field getDeclaredField(String name) 获取指定的成员变量 包含私有
注意,此时只是获取,若是需要为成员变量赋值或修改其值这需要调用setAccessible(true)方法躲过jvm的检测,暴力访问
Method m = clazz.getDeclaredMethod("setName", String.class) 获取私有成员方法
若需要执行该方法时,则需要同上调用setAccessible(true)方可执行程序;
BeanUtils 感觉跟平常的类差不多= =同样是用来封装数据的
主要有三种方法
static void setProperty(Object bean, String name, Object value) 给JavaBean对象的成员变量进行赋值
static String getProperty(Object bean, String name) 获取JavaBean对象的成员变量的值
static void populate(Object bean, Map properties) 给JavaBean对象的成员变量进行赋值
说实在的, 学了写了这么多.能记住一半我都很高兴了
憋了一个晚上才做了两道作业题,还不是很理解熟练.
有够打击的,
培优班见吧...
作者: 光宇 时间: 2018-5-13 01:26
侯玉林
今天我们学习了反射
1.什么是反射?
所谓反射就是在程序运行时,不需要new对象就能够获取该类的构造方法及其成员的一种机制.
2.我们为什么需要反射,或者说反射存在的意义是什么?
在程序后期更新开发中,由于市场更新需要,所以程序需要添加新的功能模块,但在原有代码上更新或者修改代码是灾难性的事件,在程序中各种类的关系错综复杂,牵一发而动全身,这种事别说是新程序员就是老程序员也犯怵.所以为了提高程序后期的可维护性和可扩展性,Sun公司提供了一套完整的反射机制,通过反射机制你无需去声明一个类,就可以使用其中的功能.
3.反射实现的原理是什么?
(1)当程序运行时,虚拟机先将xxx.class文件加载到方法区中.
(2)此时虚拟机中会有一个类的加载器,将方法区中的xxx.class文件生成一个xxx.class文件对象,俗称字节码对象.(对象类型:Class,位于java.lang包下.)
扩展:由于xxx.class文件只有有一个且只加载一次,所以其生成的字节码对象也只有一个,因此无论你new都是个对象,所有对象的字节码都相同.
(3)反射能够将xxx.class文件对象解剖,进而获取内部的工作方法和成员,这就是所谓的暴力反射.
4.反射的使用流程
反射的正常使用流程是,先用getxxx方法获取xxx.class文件对象中的构造方法和成员,然后在使用.
作者: doudou0606 时间: 2018-5-13 02:43
5月12日 反射
施炎生
1.反射是在运行状态中,对于任何类,都能够得到它的成员(变量,方法)。
2.获取字节码对象三种方式。
3.获取无参构造方法：（1）获取字节码对象：Class clazz = Class.forName(“包名.类名)；
（2）Constructor c=clazz.getConstructor();
4.获取有参构造方法：（1）获取字节码对象：Class clazz = Class.forName(“包名.类名)；
（2）Constructor c=clazz.getConstructor(参数类型.class；比如String.class，int.class);
5.获取public成员变量：（1）获取字节码对象：Class clazz = Class.forName(“包名.Student)；
（2）创建该类对象：Object stu=clazz.newInstance();
(3)获取该类需要操作的字段（成员变量）Field f=clazz.getFiled("age");
(4). 通过字段对象中的方法修改属性值
f.set(stu,28);
Object age=f.get(stu);
6.获取私有成员变量：在public成员变量的基础上，使用暴力获取，并调用字段对象的方法取消访问检查，暴力访问私有成员变量。
7.获取普通成员方法：（1)获取字节码对象：Class clazz = Class.forName(“包名.Student)；
(2)获取类的对象:Object stu = clazz.newInstance();
（3）//获取无参无返回值的方法：
Method m1 = clazz.getMethod("show1");
m1.invoke(p);
// 无参有返回值
Method m2 = clazz.getMethod("show2");
Object obj = m2.invoke(p);
System.out.println(obj);
// 有参无返回值
Method m3 = clazz.getMethod("show3", String.class, int.class);
m3.invoke(p, "张三", 10);
// 有参有返回值
Method m4 = clazz.getMethod("show4", String.class);
Object obj2 = m4.invoke(p, "李四");
System.out.println(obj2);
8.获取私有成员方法：在public成员变量的基础上，使用暴力获取，并调用 method.setAccessible(true)取消访问检查，暴力访问。
9.BeanUtils的常用方法
static void setProperty(Object bean, String name, Object value) 用来给对象中的属性赋值(了解)
参数1: 需要设置属性的对象 参数2: 需要修改的属性名称 参数3: 需要修改的具体元素
static String getProperty(Object bean, String name) 用来获取对象中的属性(了解)
参数1: 要获取的javaBean对象 参数2: 对象中的哪个属性
static void populate(Object bean, Map properties) 用来给对象中的属性赋值(掌握)
参数1: 要设置属性的对象 参数2: 将属性以Map集合的形式传入（Key : 属性的名称；Value: 属性具体的值）
作者: doudou0606 时间: 2018-5-13 05:11
5月12日 反射
施炎生
1.反射是在运行状态中,对于任何类,都能够得到它的成员(变量,方法)。
2.获取字节码对象三种方式。
3.获取无参构造方法：（1）获取字节码对象：Class clazz = Class.forName(“包名.类名)；
（2）Constructor c=clazz.getConstructor();
4.获取有参构造方法：（1）获取字节码对象：Class clazz = Class.forName(“包名.类名)；
（2））Constructor c=clazz.getConstructor(参数类型.class；比如String.class，int.class);
5.获取public成员变量：（1）获取字节码对象：Class clazz = Class.forName(“包名.Student)；
（2）创建该类对象：Object stu=clazz.newInstance();
(3)获取该类需要操作的字段（成员变量）
Field f=clazz.getFiled("age");
(4). 通过字段对象中的方法修改属性值
f.set(stu,28);
Object age=f.get(stu);
6.获取私有成员变量：在public成员变量的基础上，使用暴力获取，并调用字段对象的方法取消访问检查，暴力访问私有成员变量。
7.获取普通成员方法：（1)获取字节码对象：Class clazz = Class.forName(“包名.Student)；
(2)获取类的对象:Object stu = clazz.newInstance();
（3）//获取无参无返回值的方法：
Method m1 = clazz.getMethod("show1");
m1.invoke(p);
// 无参有返回值
Method m2 = clazz.getMethod("show2");
Object obj = m2.invoke(p);
System.out.println(obj);
// 有参无返回值
Method m3 = clazz.getMethod("show3", String.class, int.class);
m3.invoke(p, "张三", 10);
// 有参有返回值
Method m4 = clazz.getMethod("show4", String.class);
Object obj2 = m4.invoke(p, "李四");
System.out.println(obj2);
8.获取私有成员方法：在public成员变量的基础上，使用暴力获取，并调用 method.setAccessible(true)取消访问检查，暴力访问。
9.BeanUtils的常用方法
static void setProperty(Object bean, String name, Object value) 用来给对象中的属性赋值(了解)
参数1: 需要设置属性的对象 参数2: 需要修改的属性名称 参数3: 需要修改的具体元素
static String getProperty(Object bean, String name) 用来获取对象中的属性(了解)
参数1: 要获取的javaBean对象 参数2: 对象中的哪个属性
static void populate(Object bean, Map properties) 用来给对象中的属性赋值(掌握)
参数1: 要设置属性的对象 参数2: 将属性以Map集合的形式传入（Key : 属性的名称；Value: 属性具体的值）
作者: Yanmo_ 时间: 2018-5-13 07:29
一.反射:获取类对象(Class对象).
作用:运行时,获取类对象成员,调用成员.
主要是通过创建该类的字节码对象再来创建该类的对象
Class.forname(全类名)方法创建字节码对象,
另外还有: 类名.class 对象名.getclass
newInstance方法来创建该类的对象(通过空参)
主要的方法:
getConstructors()可以查看所有的public修饰的构造方法
getConstructor()括号带参数时,参数要用 数据类型.class ,不写为空参
通过 带有Declared的方法都是可以访问被私有修饰的方法
Field 是获取成员变量时返回的值, 有get和set方法
Invoke( 方法名,参数 )调用成员方法的方法 参数根据方法来定
注意:
通过反射获取的私有变量或者私有方法,都要用setAccessible()方法让JVM不检查.
二.JavaBean:
作用:用来封装数据,和普通的类多了生成一个序列号.
BeanUitls重要的方法:
Static void Populate(Object bean,Map map) 给对象中的属性赋值
参数1: 要设置属性的对象
参数2: 将属性以Map集合的形式传入
Key : 属性的名称
Value: 属性具体的值
注意:
在测试类中用Map集合添加的元素在对应的类中找不到相同的元素,所有需要捕获异常.
作者: 追风筝的人哇 时间: 2018-5-13 07:54
康元中
day13
今天学习了反射相关的内容
1 反射可以获取一个类的成员和构造,以前我们是通过set/get创建对象来访问,现在用反射可以通过获取该类的字节码对象
然后字节码对象调用各种方法来访问成员和构造.
首先是访问构造方法的步骤: 创建字节码对象(三种方式) Class.forName("全类名");
然后调用Class类里的方法:
///创建有参构造------重点主要是传递参数这边要注意: 传递的是有参构造的 (变量类型.class) 不要加"";
Constructor c = clazz.getConstructor(String.class,int.class);
//通过有参构造创建对象(这个对象是在这边是Student 类对象)
//这边注意( 参数的传递 )
Object stu = c.newInstance("张飞",20); //传递参数
//打印创建好的这个对象(已经重写toString 方法打印成员信息);
System.out.println(stu);
还有 Constructor[] c = clazz.getConstructors()//通过该类的字节码--可以访问所有public 修饰的构造方法;
onstructor c = clazz.getConstructor();
2 获取成员变量的步骤:
Field f = clazz.getDeclaredField("name");
f.setAccessible(true);//暴力反射(获取私有的成员一定得开true)
//通过这个字段给成员变量name赋予值;
f.set(stu, "张飞");//参数1是成员变量所在的对象/参数2是给成员变量赋的值
Object name = f.get(stu);//参数是 该成员变量所在的对象
System.out.println(name);
还有
Field[] getFields() 和 Field[] getDeclaredFields() 注意区别获取public修饰的/ 获取所有的包括私有
Object get(Object obj) 和void set(Object obj, Object value) Field 字段里的方法
Field getField(String name) 和Field getDeclaredField(String name)
3获取成员方法的步骤:
Method m = clazz.getMethod("setName",String.class);//参数1是方法的名字/参数2是参数.class
m.invoke(stu, "张飞");// 参数1是 该类所在的对象/参数2是给这个参数赋值
System.out.println(stu);// 打印对象
参照访问私有成员变量的方式,访问私有成员方法用到的方法getDeclaredMethod()
还有其他的方法:
Method[] m = clazz.getMethods();//打印public 修饰的所有方法
下午学习了BeanUtil 相关的知识
1 javaBean的封装数据的操作一些操作规范
实例化一个serv。。。的接口且随机生成一个序列号
重写set/get方法和无参构造
2学习自定义一个BeanUtil
populate（）参数一为bean对象参数二为Map集合。这个方法就是通过map集合的里面的键值对 给与bean对象
赋值。
作者: 追风筝的人哇 时间: 2018-5-13 07:57
康元中
day13
今天学习了反射相关的内容
1 反射可以获取一个类的成员和构造,以前我们是通过set/get创建对象来访问,现在用反射可以通过获取该类的字节码对象
然后字节码对象调用各种方法来访问成员和构造.
首先是访问构造方法的步骤: 创建字节码对象(三种方式) Class.forName("全类名");
然后调用Class类里的方法:
///创建有参构造------重点主要是传递参数这边要注意: 传递的是有参构造的 (变量类型.class) 不要加"";
Constructor c = clazz.getConstructor(String.class,int.class);
//通过有参构造创建对象(这个对象是在这边是Student 类对象)
//这边注意( 参数的传递 )
Object stu = c.newInstance("张飞",20); //传递参数
//打印创建好的这个对象(已经重写toString 方法打印成员信息);
System.out.println(stu);
还有 Constructor[] c = clazz.getConstructors()//通过该类的字节码--可以访问所有public 修饰的构造方法;
onstructor c = clazz.getConstructor();
2 获取成员变量的步骤:
Field f = clazz.getDeclaredField("name");
f.setAccessible(true);//暴力反射(获取私有的成员一定得开true)
//通过这个字段给成员变量name赋予值;
f.set(stu, "张飞");//参数1是成员变量所在的对象/参数2是给成员变量赋的值
Object name = f.get(stu);//参数是 该成员变量所在的对象
System.out.println(name);
还有
Field[] getFields() 和 Field[] getDeclaredFields() 注意区别获取public修饰的/ 获取所有的包括私有
Object get(Object obj) 和void set(Object obj, Object value) Field 字段里的方法
Field getField(String name) 和Field getDeclaredField(String name)
3获取成员方法的步骤:
Method m = clazz.getMethod("setName",String.class);//参数1是方法的名字/参数2是参数.class
m.invoke(stu, "张飞");// 参数1是 该类所在的对象/参数2是给这个参数赋值
System.out.println(stu);// 打印对象
参照访问私有成员变量的方式,访问私有成员方法用到的方法getDeclaredMethod()
还有其他的方法:
Method[] m = clazz.getMethods();//打印public 修饰的所有方法
下午学习了BeanUtil 相关的知识
1 javaBean的封装数据的操作一些操作规范
实例化一个serv。。。的接口且随机生成一个序列号
重写set/get方法和无参构造
2学习自定义一个BeanUtil
populate（）参数一为bean对象参数二为Map集合。这个方法就是通过map集合的里面的键值对 给与bean对象
赋值。
作者: 李成林 时间: 2018-5-13 11:20
通过反射获得对象的三种方法:
1.通过对象.class
2.通过类名.getclass;
3.通过Class.for
创建构造Constructor
1.通过字节码对象调用 Constructor方法获取构造,可以是有参构造和无参构造 然后通过构造对象调用.newInstance方法返回一个对象;
2.直接用字节码对象调用newInstance获取对象
通过反射获取变量 Field;
首先要有 字节码对象 有了字节码对象就可以获取 类的对象;
有了类字节码对象就可以通过 getDeclaredField(这里传入一个变量名,这里会自动匹配在类中是否存在这个变量,如果不存在就会报错!)方法获取变量的对象;
有了变量对象就可以获取变量中的内容get(传入一个对象获取这个对象中的内容),set(传入一个对象获取这个对象中的内容,改变的参数);
通过反射获取方法mathod
这个和获取变量的很像;
也是通过字节码对象来获取的getMethod("传入一个方法名",如果有参数就写上 参数.Class)返回的是一个对象的字节码;
然后在对象的字节码后面点上一个invoke(传入一个类的对象,有参传参,没有就算了);
暴力反射setAccessible(true)
就是在你获取到的字节码变量或是字节码方法后面点上一个setAccessible(true),就可以让虚拟机无视你的权限修饰符都默认成public; 这样就可以随意访问了;
BeanUtils工具类的方法
static void setProperty(需要修改的对象, 变量名, 修改的参数)// 给JavaBean对象的成员变量进行赋值
static String getProperty(Object bean, String name) // 获取JavaBean对象的成员变量的值
将map对象中的内容传给对象,key是对象中的变量,value是变量的值;
static void populate(Object bean, Map properties)//// 给JavaBean对象的成员变量进行赋值
作者: chenyelong 时间: 2018-5-14 22:03
陈叶隆
今天学习了web前端开发,学习了html的一些书写格式,比如列表<ol>,字体<font>,超链接<a href=””>,超链接后面接的是要链接的路径,<form action>链接的是提交的路径,这两个区别我很容易搞混.还有<table>里面嵌套<table>看着逻辑不是很复杂,实际操作起来却很难.<form>的格式是<input type=”” name>,这里最重要的是一定要写name,这个是以后跟我们后台接收数据息息相关的.
作者: 李成林 时间: 2018-5-14 23:44
李成林
html的学习总结
今天学习的内容很多都是需要记忆的在逻辑上没有太大问题
主要学习的标签有:
排版标签:<h><p><b><i><u>
图片标签:"<img src width height alt>
序列标签: 有序<ol><li>无序<ul><li>
超链接: <a> 属性herf连接路径 target 打开方式有_self,_blank;
表格标签:<table>属性有width.height.border(边界).align(位置)
<tr>行属性有 background(背景图片)<td>列属性colspan(跨列合并)rowspan(跨行合并)
表单标签:<form>(在form范围内的可以跳转)
form属性action提交路径 method 提交方式
<input(输入) type.......>
text 文档框
password 密码框
radio单选
checkbox 复选
button 普通按钮
fiel 文件
reset重置
hiddn隐藏
下拉列表:<select>(挑选)<option>(选项)
文本域:<textarea> 属性cols 列 rows 行
作者: Do1 时间: 2018-5-16 09:07
今天学习了DIV
DIV在HTML前端页面布局中，非常重要，我们经常遇到的问题是：DIV居中，DIV自适应高度等等，下面就来总结一下。
多个div使用会自动换行，应该使用float属性
left : 对象浮在左边
right : 对象浮在右边
例如：
float: left 和 float: right 是两个div左右排列在同一行
<div style="width: 20%; float: left; height: 100%">图片</div>
<div style="width: 50%; float: right; height: 100%">图片</div>
等，所以div很好用
作者: 李志勇 时间: 2018-5-23 20:41
李志勇:
bootstrap:
http://www.bootcss.com
-全局CSS样式
- 组件
- javaScript插件
这三个查询 可以更快更加准确的对HTML页面作的更加美观;
MYSQL:
是文件管理系统 关系型数据库,存放的是实体之间的关系;
学习了 数据库的增删改查 这些功能 初步的接触数据库;
一台数据库服务器中会创建很多数据库（一个项目，会创建一个数据库）。在数据库中会创建很多张表（一个实体会创建一个表）。在表中会有很多记录（一个对象的实例会添加一条新的记录）。
create database 数据库名 [character set 字符集 collate 字符集校对规则];
?查看数据库服务器中所有的数据库：show databases;
查看某个数据库的定义信息： show create database 数据库名称
alter database 数据库名称 character set 字符集 collate 校对规则;
drop database 数据库名称
?切换数据库：use 数据库名称;
查看当前正在使用的数据库 selecte database();
?create table 表名称(字段名称 字段类型(长度) 约束,字段名称 字段类型(长度) 约束…);
作者: zzx835387607 时间: 2018-6-10 00:47
郑志祥
反射可以干嘛（目的）？
操作类中的属性，方法，构造。
new 对象也可以操作 为什么要用反射？
因为有些时候，
比如私有的构造方法，new不出来，可以通过反射来获取。
Web.xml的Servlet就是通过反射来实现的（权限地名）
获得类字节码对象三种方式；
1.通过类名.clss （在javaBean使用）
2.通过对象getclass
3.使用class的forname的静态方法获得（推荐使用）因为通用性比较高。可以在java中编写，也可以在web.xml的配置文件使用。
二。通过反射来操作构造方法
反射的第一步都是获得对象。
第二步获取有参构造（如果是私有的构造）
getDeclaredConstructor
setAcceddible（解除私有构造）
三。通过反射来获得属性（field）
clazz.getDeclaredField（获得私有的属性）
setAcceddible（解除私有构造）
四，通过反射获得类中的方法（掌握）
.getDeclaredMethod
利用BeanUtils需要到2个包 1.dbUtils 2.logging
事物是对数据库mysql的操作，与java代码无关
为什么要在Service添加事物管理？
因为Service是调用Dao里面的方法，我们是要让这两个方法同时进行。（要嘛都成功，要嘛都失败）
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |
