反射（学习整理）----操作类、属性、方法！

 　　刚学的反射，利用博客写一篇笔记！（附上代码！）

1、下面是我的分析笔记

其他：
    1、用static修饰的归位类所拥有的，没有static修饰的归对象拥有！
    
    2、




反射机制：
    不需要用到new，反射不需要new!

    反射是程序运行的时候动态地加载类的属性和方法
    
    获取类对象类型中的内容，都必须通过classType对象
    步骤：
          1、获取类的对象类型

            语法格式：    
                Class cls=Class.forName("包名.类名");
            举例：
                Class<?> classType=Class.forName("cn.jason.reflections.Constomer");
            说明：
                此处的？代表任意类型对象，相当于Object

          2、通过反射，获取类对象里面的所有属性

            语法格式：
                Field[] fields=classType.getDeclaredFields();

                //循环打印获取到的属性Name
                for (Field field : fields) {
                    System.out.println(field.getName());
                }
          3、通过反射，获取类对象里面的所有方法或指定的方法
            
            1）、获取所有的方法
                //获取类中的所有的方法
                Method[] methods=classType.getMethods();
                for (Method method : methods) {
                    System.err.println(method.getName());
                }

            2）、获取指定方法名称的方法

                //属性的第一个字母截取出来，并且大写化
                String firstLetter=name.substring(0, 1).toUpperCase();
                
                //拼接属性get方法的方法名
                String getMethodName="get"+firstLetter+name.substring(1);
                String setMethodName="set"+firstLetter+name.substring(1);
        
                //现在动态获取get方法
                    Method getmethod=classType.getDeclaredMethod(getMethodName, new Class[]{});
                
                //现在动态获取set方法   参数列表：(int id)
                    Method setmethod=classType.getDeclaredMethod(setMethodName, new Class[]{field.getType()});
            
        分析说明一下：
            （1）getDeclaredMethod(getMethodName, new Class[]{});
                
                该方法的第一个参数，是需要获取方法对象的方法名，

                该方法的第二个参数，是执行方法的参数类别的， 的参数类型的数组

            （2）getDeclaredMethod(setMethodName, new Class[]{field.getType()});

                 其中的field.getType()是获取类字段的类型
        
            （3反射程序中，关于参数类型的对象数组：用Class[]{}存放
                       具体的数据类型：用int.class、String.class等形式
                       提示：Integer.TYPE 效果等价于 int.class
        
        
        4、通过反射，获取类对象（要执行反射的获取的方法，前提就是要获取类的对象，但不是new出来的，是反射获取得到的!）
        
            //通过反射来创建对象：等同于Constomer c=new Constomer(001,"Jason")：构造器-----这里的目的是获取类的对象（反射的形式获取）
                    Object obj=classType.getConstructor(new Class[]{int.class,String.class})
                                        .newInstance(new Object[]{18,"天使彦"});    

            分析一下：
                1）、这个方法是使用反射机制获取类的对象的，类似new出来的实例！

                2）、其中：getConstructor（new Class[]{int.class,String.class}）
                       
                       说明：参数列表放的是：构造方法的参数列表的数据类型、或数据类型的集合

        
        5、执行方法---是否有返回值  根据方法的返回类型来确定    
            
            语法格式：    
                方法对象.invoke(类对象,实参数据集合)
                
            举例：
                setmethod.invoke(obj,(new Object[]{18,"天使彦"});
            
                Object value=getmethod.invoke(obj,(new Object[]{});
        
            说明一下：
                实参数据集合：放在Object[]中，毕竟是参数据是可以为各种类型的！

  2、下面是测试源码

实体类： 

package cn.jason.reflections;

/**
 * 反射测试：
 *         用户类
 *    Created by Jason  2016-7-16  上午11:22:03
 */
public class Constomer {

    /**
     * 成员变量
     */
    private int id;            //用户id
    private String name;    //用户姓名
    
    /**
     *构造器：
     */
    public Constomer(){
        
    }
    public Constomer(int id,String name){
        this.id=id;
        this.name=name;
    }
    
    /**
     * getter和setter方法
     */
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    
}

  反射测试类：

package cn.jason.reflections;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 *    Created by Jason  2016-7-16  上午11:31:04
 */
public class TestReflect {
    
    public static void main(String[] args) {
        TestReflect.getproperty();
    }

    /**
     * 获取用户类型里面的属性以及getter好getter方法
     */
    public static void getproperty(){
         try {
            //第一步：获取对象类型
            Class<?> classType=Class.forName("cn.jason.reflections.Constomer");
            
            //通过反射，获取用户类里面的所有属性
            Field[] fields=classType.getDeclaredFields();
            
            //循环打印获取到的属性Name
            int i=0;
            for (Field field : fields) {
                String name=field.getName();
                //System.out.println("类对象的字段名称："+name);
                
                //属性的第一个字母截取出来，并且大写化
                String firstLetter=name.substring(0, 1).toUpperCase();
                
                //拼接属性get方法的方法名
                String getMethodName="get"+firstLetter+name.substring(1);
                String setMethodName="set"+firstLetter+name.substring(1);
                //System.err.println("拼接后的方法名称："+getMethodName+","+setMethodName);
                
                //现在动态获取get方法
                    Method getmethod=classType.getDeclaredMethod(getMethodName, new Class[]{});
                
                //现在动态获取set方法   参数列表：(int id)
                    Method setmethod=classType.getDeclaredMethod(setMethodName, new Class[]{field.getType()});
                    
                //通过反射来创建对象：等同于Constomer c=new Constomer(001,"Jason")：构造器-----这里的目的是获取类的对象（反射的形式获取）
                    Object obj=classType.getConstructor(
                                            new Class[]{int.class,String.class}).newInstance(
                                            new Object[]{18,"天使彦"});
                //执行get方法获取数据        空参数
                    Object value=getmethod.invoke(obj, new Object[]{});
            
                    System.out.println("[1]执行了方法"+getMethodName+"()之后,返回结果是："+value);
                    
                //执行set方法:2次遍历的参数类型是不一样的！所以不能写死了！否则会报参数类型错误！
                    Object[] params=new Object[1];
                    if(i==0){
                        params[0]=22;
                    }else{
                        params[0]="Jason";
                    }
                    setmethod.invoke(obj, params);
                    Object value2=getmethod.invoke(obj, new Object[]{});                    
                    System.out.println("[2]执行了方法"+getMethodName+"()之后,返回结果是："+value2);
                    
                    //计数器+1
                    i++;
            }
            
            //获取类中的所有的方法
            Method[] methods=classType.getMethods();
            for (Method method : methods) {
                //System.err.println(method.getName());
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  测试运行结果： 

[1]执行了方法getId()之后,返回结果是：18
[2]执行了方法getId()之后,返回结果是：22
[1]执行了方法getName()之后,返回结果是：天使彦
[2]执行了方法getName()之后,返回结果是：Jason
下面是获取反射对象内部全部的方法
getName()
getId()
setName()
setId()
wait()
wait()
wait()
hashCode()
getClass()
equals()
toString()
notify()
notifyAll()