反射

    定义：在运行时获取任意类的方法属性，调用任意对象的所有方法和属性
    前提：获取类的对象(Class字节码对象)：A:类的对象.getClass  B:静态调用 类名.class C:静态调用 Class.forname("全类名")
    获取构造方法： 1、获取public构造方法
                     A:Constructor<?>[] getConstructors();获取所有public的构造方法
                     B:Constructor<T>  getConstructors(Class<?>...parameterTypes);有参传入参数类型字节码，无参不传        
                         ->字节码对象.newInstance(); [Constructor的方法：T newInstance(Object initargs)]
                 3、获取私有构造方法 
                     Constructor<T> getDeclaredConstructor(Class<?>...parameterTypes):                                
                         [clazz.getDeclaredConstructor(无参/有参);]
                         [去除私有权限c2.setAccessible(true);]

//公共无参构造方法
        Constructor cc = clazz.getConstructor();
    //获取构造方法的对象
        Object oo = cc.newInstance();
        System.out.println(oo);
//公共无参构造快捷创建对象
        Object stu = clazz.newInstance();
        System.out.println(stu);
        
//公共有参构造
        Constructor c= clazz.getConstructor(String.class,int.class);
        Object stu2 = c.newInstance();
        System.out.println(stu2);
  

        //获取私有构造
        Constructor stu3 = clazz.getDeclaredConstructor(int.class,String.class);
        //去除私有权限
        stu3.setAccessible(true);
        //创建对象
        stu3.newInstance("jack",12);
        System.out.println(stu3);

    获取成员变量：    1、获取所有public的成员变量
                        Field[] getFields();获取所有的公共字段对象
                        Field getField(); 根据字段名获取公共字段对象
                    2、获取private的成员变量
                        Field[] getDeclaredFields();
                        Field getDeclaredField(String.class);
                        [去除私有权限 void setAccessible(true);]
                    3、Field方法：
                        Object get(Object obj);
                        void set(Object obj,Object value);

Class clazz = Class.forName("fanS.Student");
////公共无参构造快捷创建对象
Object stu = clazz.newInstance();

//获取公共的成员变量
Field f1 = clazz.getField("name");
f1.set(stu, "jack");
Object o1 = f1.get(stu);
System.out.println(o1);

Class clazz = Class.forName("fanS.Student");
    //公共无参构造快捷创建对象
Object stu = clazz.newInstance(); 
    //获取私有的成员变量
Field f2 = clazz.getDeclaredField("age");
     //去除私有权限
f2.setAccessible(true);
f2.set(stu, 12);
Object o2 = f2.get(stu);
System.out.println(o2);

System.out.println(stu);

    获取成员方法：   A:无参&无返回值 
                   B:无参&有返回值 
                   C:有参&无返回值
                   D:有参&有返回值
                   1、获取public方法：Method getMethod(String name,Class<?>...parameter);传入方法名，参数类型字节码，调用方法
                       Method getMethod()->invoke()[有参要有Object接收]    
                   2、获取private方法：Method getDeclaredMethod(String name,Class<?>...parameter)
                       Method getDeclaredMethod()->setAccessible(true);->invoke()
                        [暴力反射，破坏安全性，不提倡使用]
                   3、method方法：
                       Object invoke(Object obj,Object...args)
                       getMethod();公共
                       getDeclaredMethod();私有

//获取共有方法
Class clazz = Class.forName("fanS.Student");
Object stu = clazz.newInstance();
//无参
Method m1 = clazz.getMethod("showpub");//公共
m1.invoke(stu);
//有参
Method m3 = clazz.getMethod("sum", int.class,int.class);//公共
Object sumo = m3.invoke(stu, 1,2);
System.out.println(sumo);

//获取私有方法

Class clazz = Class.forName("fanS.Student");
Object stu = clazz.newInstance();
//无参
Method m2 = clazz.getDeclaredMethod("showpri");//私有
m2.setAccessible(true);
m2.invoke(stu);
//有参
Method m4 = clazz.getDeclaredMethod("str", String.class,String.class);//私有
m4.setAccessible(true);
Object newStr = m4.invoke(stu, "abc","ABC");
System.out.println(newStr);

JavaBean类：用于封装数据
    类使用公共类修饰
    成员变量私有修饰(保证安全性)
    为成员变量提供get，set方法
    提供公共构造方法
    实现序列号接口  (Serializable)

BeanUtils工具类(需导入jar包，为Apache提供)
    常用方法：  void setProperty(Object bean,String name,Object value);给JavaBean对象的成员变量赋值
              public static String getProperty(Object bean,String name);获取值

Person p = new Person();
//System.out.println(p);

//static void setProperty(Object bean, String name, Object value) ：给JavaBean对象的成员变量进行赋值
BeanUtils.setProperty(p, "name", "zhangsan");
//BeanUtils.setProperty(p, "age", 18);
//System.out.println(p);

//static String getProperty(Object bean, String name) 
String name = BeanUtils.getProperty(p, "name");
System.out.println(name);

void populate(Object bean,Map values);[map<String,Object>]  赋值

Person p = new Person();
//一个p可添加多组人员信息
Map<String,Object> map = new HashMap<String,Object>();
map.put("name", "lisi");
map.put("age", 18);
map.put("gender", "male");

BeanUtils.populate(p,map);
System.out.println(p);

小栗子

自定义BeanUtils类
        public class MyBeanUtils {
            private MyBeanUtils() {}
            
            //public static void setProperty(Object bean,String name,Object value)
            public static void setProperty(Object bean,String name,Object value) throws ReflectiveOperationException {
                //根据JavaBean对象获取对应的字节码对象
                Class clazz = bean.getClass();
                //根据字节码对象获取对应的Field对象
                Field f = clazz.getDeclaredField(name);
                //设置权限，让虚拟机不进行访问的检查
                f.setAccessible(true);
                //赋值
                f.set(bean, value);
            }
            //public static String getProperty(Object bean,String name)
            public static String getProperty(Object bean,String name) throws ReflectiveOperationException {
                Class clazz = bean.getClass();
                Field f = clazz.getDeclaredField(name);
                f.setAccessible(true);
                Object obj = f.get(bean);
                return obj.toString();
            }
            
            //public static void populate(Object bean,Map map)
            public static void populate(Object bean,Map map) throws ReflectiveOperationException {
                //通过JavaBean对象来获取对应的字节码对象
                Class clazz = bean.getClass();
                //获取Map中所有的key
                Set keys = map.keySet();
                for (Object key : keys) {
                    try {
                        //根据key来获取对应的Field对象
                        Field f = clazz.getDeclaredField(key.toString());
                        //根据key来获取Map中对应的value
                        Object value = map.get(key);
                        
                        f.setAccessible(true);
                        f.set(bean, value);
                        
                        //setProperty(bean, key.toString(), map.get(key));    继续调用上面写好的setProperty()方法
                    } catch(NoSuchFieldException e) {
                        //e.printStackTrace();
                    }
                }
            }
        }