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

【理解】阐述什么是反射机制
【应用】阐述什么是字节码对象、以及获取的三种方式
【应用】通过反射操作构造方法、成员方法、成员属性
【理解】阐述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。可以使用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和反射的原理，对对象的多个值赋值，这个很好用！

   林文辉 反射总结       反射的特性比较高级,只要获取到类名,就可以获取到类的内部的所有成员和所有方法.就单纯对程序来说确实是提高了程序的灵活性.但是同时可能带来意料之外的问题.并且反射代码通常比我们正常写的代码要麻烦,相当于拐了个弯.而且反射是通过类名对类的类部进行一系列的操作,这样可能会导致后期维护的难度增加.
       字节码对象说白了就是.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软件。有破解方法是否有防御之道？为何要设计权限这么大的机制？
   扯远了。有空查查资料。总结一下今天的学习情况。
   
   一、反射:
   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工具类。通过反射能够很容易地写出来
       听说总结不用贴代码。

郑志祥
反射可以干嘛（目的）？
操作类中的属性，方法，构造。


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里面的方法，我们是要让这两个方法同时进行。（要嘛都成功，要嘛都失败）

李志勇:
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 表名称(字段名称 字段类型(长度) 约束,字段名称 字段类型(长度) 约束…);

今天学习了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很好用

李成林
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 行

陈叶隆
今天学习了web前端开发,学习了html的一些书写格式,比如列表<ol>,字体<font>,超链接<a href=””>,超链接后面接的是要链接的路径,<form action>链接的是提交的路径,这两个区别我很容易搞混.还有<table>里面嵌套<table>看着逻辑不是很复杂,实际操作起来却很难.<form>的格式是<input type=”” name>,这里最重要的是一定要写name,这个是以后跟我们后台接收数据息息相关的.

通过反射获得对象的三种方法:
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对象的成员变量进行赋值

康元中
  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对象
        赋值。

康元中
  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对象
        赋值。

一.反射:获取类对象(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集合添加的元素在对应的类中找不到相同的元素,所有需要捕获异常.

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:  属性具体的值）

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:  属性具体的值）
     

侯玉林

今天我们学习了反射
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文件对象中的构造方法和成员,然后在使用.
       

任佳锋

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对象的成员变量进行赋值

说实在的, 学了写了这么多.能记住一半我都很高兴了
憋了一个晚上才做了两道作业题,还不是很理解熟练.
有够打击的,
培优班见吧...

16lws
今天学习了反射,反射是java中提供的另一种获取构造方法,成员的暴力机制,它把,构造方法,成员变量,成员方法各自封装成一个独立的类,通过这些封装的类的对象可以对构造方法,成员变量,成员方法进行操作.还学习了使用BeanUtils来封装数据,并自己实现Beanutils功能.具体如图

康元中
  今天学习反射,反射是一种可以动态访问一个类的成员和构造.
第一个重点  掌握如何去访问一个类的构造/方法和变量
    都是通过创建字节码对象 然后通过字节码对象调用一些方法 返回到相对应的字段/ 构造/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(标准书写规范)

发了两个楼。发了两个楼。发了两个楼。发了两个楼。

反射

在运行时可以获得任何一个类的成员属性和方法,通过暴力反射可以获取类的私有成员;

首先要获取class对象,然后通过获取构造方法获取实例化对象

创建class对象有三种方式,:

1 通过已存在的对象名加上getclass

2通过类名点上class

3是通过class的静态方法 Class.forName 推荐使用这种方法,比较方便点

然后又学了getConstructor()

构造方法可以是有参构造,但实例化是一定要相互匹配上

getDeclaredField(Stringname) --> 暴力反射获取指定名称字段

记得要加dsetAccessible(boolean flag) --> 让jvm不检查权限  不然就获取不到私有的

谢洪彬:
     
   关键字:   反射   ,    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集合一起进行操作.