通过反射调用运行时类的各种属性

反射：

反射是动态语言的关键，反射机制运行java在执行期间，借助Reflection提供的API取得任何类的内部信息，
并能直接操作任意对象的内部属性与方法
本文只是自学菜鸟的一些总结，菜得很，希望大佬的指正和纠错

供以下程序操作的Person类

package java1;

@MyAnnotatino(value = "hi")
public class Person extends Creature<String> implements Comparable<String>,Myinterface{
    private String name;
    int age;
    public int id;


    @MyAnnotatino(value = "abc")
    public Person() {
    }
    @MyAnnotatino
    private Person(String name){
        this.name = name;
    }

    @MyAnnotatino
    public String getName() {
        return name;
    }

    private String show(String nation){
        System.out.println("我的国籍是" + nation);
        return nation;
    }

    public void setName(String name) {
        this.name = name;
    }
    @MyAnnotatino
    public int getAge() {
        return age;
    }
    @MyAnnotatino(value = "hi")
    public void setAge(int age) {
        this.age = age;
    }

    public String display(String interests){
        return interests;

    }
    @Override
    public void myvoid() {
        System.out.println("一个人");
    }


    @Override
    public int compareTo(String o) {
        return 0;
    }

    public static void main(String[] args) {
        ReflectionTest.Person p1 = new ReflectionTest.Person();
        System.out.println();
    }

    private static void showDesc(){
        System.out.println("我是一个人");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

通过反射调用运行时类的属性

其实通过反射调用运行时类的各种属性的步骤都是一样的，只是各个方法名不同。
以获取类中的属性为例：

Class clazz = Person.class;
       //获取所有属性结构:getFields
        Field[] field = clazz.getFields();
        for (Field f:field){
            System.out.println(f);
        }
        //getDeclaredFiels:获取运行时类自己声明过的属性，不考虑权限，不包含父类中声明的属性
        Field[] declaredFields = clazz.getDeclaredFields();
        //用增强for循环输出
        for (Field f:declaredFields){
            System.out.println(f);
        }

通过反射获取运行时类的各种权限修饰符，方法，注解等等

其实步骤和上面是一样的，只是有一些细微的差距

//获取权限修饰符
 Class clazz = Class.forName("java1.Person");
        Field[] df = clazz.getDeclaredFields();
        for (Field f:df){
            //权限修饰符:getModifiers,获取权限修饰符,int类型：0:default,1:public,2:private,3:protected
            //将int型权限修饰符变为字符串形式：Modifier.toString
            System.out.println(Modifier.toString(f.getModifiers()));
            //数据类型：getType
            System.out.println(f.getType().getName());
            //变量名：getname:获取变量名
            System.out.println(f.getName());

//获取方法声明的注解，形参列表，异常，形参名等

     Class<Person> clazz = Person.class;
        Method[] me = clazz.getDeclaredMethods();
        for (Method m:me){
            //getAnnotations:获得当前方法的所有注解
            Annotation[] ann = m.getAnnotations();
            for (Annotation a:ann){
                System.out.println("注解为"+a);
            }
            System.out.println(Modifier.toString(m.getModifiers()) );
            //返回值类型returnType:返回型类型的名字：getName
            Class<?> returnType = m.getReturnType();
            System.out.println(returnType.getName());
            //方法名:getName:通常情况方法名后会配合形参列表
            System.out.print(m.getName());
            System.out.print("(");
            //形参列表:获取形参类型方法：getParameterTypes
            //获取形参名：
            Class<?>[] types = m.getParameterTypes();
            if (!(types == null&& types.length == 0)){
                for (int i= 0;i<types.length;i++){
                    //获取形参名,如果形参是最后一个，就不加逗号
                    if (i == types.length-1){
                        System.out.print(types[i].getName()+"args_"+i);
                        break;
                    }
                    System.out.print(types[i].getName()+"args_"+i+",");

                }
                System.out.print(")");
                //抛出的异常:getExceptionTypes
                Class<?>[] ex = m.getExceptionTypes();
                if (!(ex == null&&ex.length ==0)){
                    System.out.println("throws");
                    for (int i =0;i<ex.length;i++){
                        if (i == ex.length-1){
                            System.out.println(ex[i].getName());
                            break;
                        }
                        System.out.println(ex[i].getName() + "i");
                    }
                }
            }
            //
            System.out.println("*********");


        }



    }
}

通过反射操作运行时类的属性，方法

操作属性方法时，一般使用getdeclared的相关方法，因为此类方法可以调用任何权限修饰符的方法属性
其中的关键方法为：setAccessible()，将形参填入true时，就可以保证属性和方法的修改和访问

 public void Test2() throws Exception {
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();
        //getDeclaredField(String name)
        Field name = clazz.getDeclaredField("name");
        //为了避免出现非法访问的情况，必须在设置之前进行setAccessible方法，保证当前属性是可访问的
        name.setAccessible(true);//保证当前属性时可访问的
        name.set(p,"ljy"); //此时出现IllegalAccessException：非法访问，即文件找到了但是没有权限访问
        System.out.println(name.get(p));


    }

总结

通过反射操作运行时类中的属性方法步骤其实都是一样的
1.获取运行时类的class。
2.创建运行时类的对象(供非static的结构使用)
3.调用目标类型的get或getdeclared方法
4.需要操作时，为了确保可访问，调用setAccessible方法
5.调用set，get等方法进行操作