柯威龙
反射是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集合的的形式传入

郑雪平

今天学习了反射这个知识点,知道了原来反射挺好用的,它在运行时可以使用暴力手段调用任何类并获取所有属性和方法,我们想知道的字节码里的所有信息,在只知道类名的情况下就能调取字节码对象,而且还可以通过三种方法获取.
  使用f.setAccessible(true)开关可以免检查,用JavaBean进行数据封装,可以简化代码流程,使用起来方便了许多.

许煜
    每日总结
反射:通过字节码文件完成对数据的处理   
优点:可做到无视权限
缺点:数据类型精度有所损失,如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)也是用于设置成员变量

反射总结-------林树德
今天学习了反射,反射可以通过暴力方法获取对象的成员变量及构造方法,及大提高了以前通过对象来获取方法的效率,字节码对象可以通过类名.class,对象名.get.Class()及Class.forName(“com.itheima_01.Student”)来货取;beanutils可以很方便的提高我们的开发效率.需要通过导包才能获取其中方法;

陈旭明
      上午学习了创建对象的另外一种方式,然后可以通过对该对象的反射操作获
取非public修饰的成员(包括成员变量和成员方法),并能对成员进行一系列操作
(主要是对成员进行获取和赋值)。非public(private、protect、   )修饰的成员
优先考虑用反射。下午学习了Beanutils的三种方法:BeanUtils.getProperty、
BeanUtils.setProperty、BeanUtils.populate,前面两种作为了解,重点掌握
BeanUtils.populate方法就好,该方法主要是运用HashMap,然后对成员变量
进行赋值,底层也是通过反射的原理实现的。

柯威龙
反射是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集合的的形式传入

吴鹏

字节码对象获得的方式有三种
新建对象后用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这个键在对象中是否存在.

郑泽珑

一、反射
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方法的重写,用到的是反射

詹源
学习反射后,获取调用成员的行为变得更加快捷和灵活;
反射的面向对象性更强;反射较依赖字节码对象来完成操作;
BaanUtils工具类更加方便的对对象属性进行获取,修改,赋值.

凌辉：
总结:
今天学习了反射
反射获取类的对象,等于一个人去解剖,拿里面的所有东西去用;
有时候会遇到不能修改类的情况,直接通过反射就可以解决了;
还学习了封装数据的JavaBean,通过BeanUtils简化操作

刘文峰:
反射
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集合中,通过遍历集合然后筛选为成员变量赋值

凌辉：
总结:
今天学习了反射
反射获取类的对象,等于一个人去解剖,拿里面的所有东西去用;
有时候会遇到不能修改类的情况,直接通过反射就可以解决了;
还学习了封装数据的JavaBean,通过BeanUtils简化操作

反射：在程序运行时，获取一个对象的所有信息，将其储存到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的区别

郑阳阳
反射学完后获取对象变得很简单 只需要有对象的字节码就可以.
                获取字节码对象的三种方式:
                (1)对象.getclass()
                (2)类名.Class
                (3)Class.forName(全类名)
通过调用Class的方法可以获取对象的public修饰的构造getConstructor(加了s获取所有构造),可以获取public修饰的字段对象Field getField
(加了s获取所有字段),还可以调用对象的方法getMethod,前面的方法中间加了Declared可以获取被私有的构造,变量和方法,也是暴力访问的前提.
setAccessible这个是暴力访问的开关,参数为true,取消java访问检查,开了之后就和开挂了一样可以为所
欲为随便获取和修改变量和方法.

BeanUtils有三个方法可以给对象的成员变量赋值和获取成员变量的值,最好用的是populate可以配合Map集合使用

反射总结
何平波
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-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(类名,集合名)来直接获得,这样更加的方便

郑学馨
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给对象赋值)对比反射的赋值方式简单化很多,推荐使用,

                苏海斌
反射就是在运行状态中,能够获取任意一个类的所有对象和方法,包括私有的
                字节码对象获取的三种方式
                对象名+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)赋值

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

吴俊斌
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可以获取对象中所有的属性赋值