笔记：Java反射机制基础

反射在百度的解释为“一种计算机处理方式，是程序可以访问、检测和修改它本身状态或行为的一种能力”，即在运行的时候可以分析代码的内容，包括注解的内容，得到需要的信息。就像在常用的IDE如Eclipse中利用了反射实现了获取类的信息。

1.Class

java.lang.Class没有公共的构造方法，因此单独声明一个Class对象是不允许的；每个类型都有一个Class对象，这个Class对象记录了改类型的interface，field，method，annotation，generics等。任何类型，包括基础数据类型（int, short, long, float, double, char, btye, boolean)以及void类型都有对应的Class对象。

package com.test.ReflectTest;
/**
 * @author 王狗蛋 
 * @date : 2017年8月13日 上午11:42:42
 */
public class Reflect {
    public static void main(String...args) throws Exception {
        // The first method to get a class object
        // This method will throws ClassNotFoundException
        Class<String> clz = (Class<String>)Class.forName("java.lang.String");
        // The second method to get a class object
        clz = String.class;

        // Now let check the attributes of clz
        System.out.println("The name of clz is " + clz.getName());
        System.out.println("Is clz a primitive " + clz.isPrimitive());

        // Of course we can check whether an object is specific class               
        System.out.println("Is string is a String " + clz.isInstance("string"));
        // And there is another method to print info
        System.out.println(clz.toGenericString());

        // Of course we can create an instance
        String instance = clz.newInstance();
        System.out.println(instance instanceof String);
    }
}

输出结果
The name of clz is java.lang.String
Is clz a primitive fase
Is string is a String true
public final class java.lang.String
true

从结果可知，clz的类名为java.lang.String，并且clz不是一个基础类型，“string”字符串是clz的类型，Class这个类是一个public final 类，由于被final修饰，Class在创建之后不会被修改，保证了代理时的安全性

2.interface
接口不能实例化并且包含了所有继承类应包含的所有方法，但接口可以被访问，也可以调用里面的方法。调用方法会在介绍invoke方法的笔记中记录 。
我们都知道String类继承Serializable，Comparable；但String类到底都继承了那些接口呢，我们来下面代码：

        /** 这段代码接上述代码 */
        Class<?>[] inters = clz.getInterfaces();
        for (Class<?> inter: inters) {
            System.out.println(inter.toGenericString());
        }

结果如下：
public abstract interface java.io.Serializable
public abstract interface java.lang.Comparable
public abstract interface java.lang.CharSequence

这三个接口就是String类继承的接口，其中Serializable就是可序列化接口，使得该类型的对象可以通过IO输出；Comparable用于实现俩个对象之间的比较，并通过方法compareTo(T object)来制定比较规则 ；CharSequence是String和AbstractStringBuilder的接口，具体内容在String笔记中介绍（我也不知道这个笔记什么时候整理，一般String和StringBuilder就够用了）

3.Field
域就是类的属性，我们可以通过一个Class对象来获取field
首先我们先弄一个类用来演示：

package com.test.ReflectTest;

/**
 * @author 王狗蛋 
 * @date : 2017年8月13日 下午12:21:06
 */
public class DemoClass {
    public int num1 = 1;
    protected int num2 = 2;
    int num3 = 3;
    private int num4 = 4;
    public static int num5 = 5````


}

然后我们继续在main方法中演示：

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;


        Class<?> clzDemo = Class.forName("com.test.ReflectTest.DemoClass");
        Object obj = clzDemo.newInstance();
        Field field = clzDemo.getField("num1");

        System.out.println(field.toGenericString());
        System.out.println(Modifier.toString(field.getModifiers()));
        System.out.println(field.getType().toGenericString());
        field.set(obj, 10);
        System.out.println(field.get(obj));

输出结果：
public int com.test.ReflectTest.DemoClass.num1
public
int
10

首先先用clzDemo.getFIeid(“field name”)获取了name为”num1”的域
然后field.getModifiers()获取field的修饰类型，但获得的是一个int型对象，需要通过Modifier的静态方法toString（int）来输出；field.getType()获取域的数据类型；通过set方法来修改值并通过get方法获取值；

在set(Object obj, Obejct value)方法中修改对象为obj的域，但num5是一个静态属性，即在内存中只存放一个num5对象，即使创建多个对象，每个对象的num5都是引用内存中那唯一的num5域的值。
所以在set()方法时，如果该域是一个静态的域，那么在传入第一个参数时可以传入空指针null，即set(null,20);这时所有对象的num5都被改为20。

可能你会想这样一个一个域取很麻烦，当然有简单的方法：

        Field[] fields = cls.getFields();
        for (Field field: fields) {
            System.out.println(field.toString() + "\t" + field.get(obj));

        }

输出结果：
public int com.test.ReflectTest.FieldDemo.num1 1
public static int com.test.ReflectTest.FieldDemo.num5 10

诶，等等，明明有5个域，你怎么就把public的域输出出来了呢？这是因为getFields()方法只会返回public域，对于private protected 和默认类型不会输出，这时我们就需要用到另一个方法getDeclaredFields()

        fields = cls.getDeclaredFields();
        for (Field field: fields) {
            //field.setAccessible(true);
            System.out.println(field.toGenericString() + "\t" + field.get(obj));
        }

这时候一定会报一个java.lang.IllegalAccessException异常，这个异常就是说没有访问权限造成的异常，这时把注释掉那行代码加上就不会有问题了，哈哈神奇吧。
输出结果：
public int com.test.ReflectTest.FieldDemo.num1 1
0
protected int com.test.ReflectTest.FieldDemo.num2 2
int com.test.ReflectTest.FieldDemo.num3 3
private int com.test.ReflectTest.FieldDemo.num4 4
public static int com.test.ReflectTest.FieldDemo.num5 5

为什么会这样呢，Accessible = true 会忽略访问权限的限制，具体会在invoke方法介绍的笔记中介绍。

4.Method
方法就是定义在类中的所有方法，构造方法需要用构造调用

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.Modifier;

        Method[] methods = clz.getMethods();
        for (Method method: methods) {
            System.out.println("-----------------------");
            System.out.println("name:" + method.getName());
            System.out.print("defaultValue:" + method.getDefaultValue());
            System.out.print("generic return type:" + method.getGenericReturnType());
            System.out.print("return type：" + method.getReturnType());
            System.out.print("modifiers:" + Modifier.toString(method.getModifiers()));
            // Parameters
            Parameter[] parameters = method.getParameters();
            System.out.print(parameters.length + "parameters:");
            for (Parameter para: parameters) {
                System.out.print("name:" + para.getName());
                System.out.print("type:" + para.getType().toString());
            }
            Class<?>[] parameterTypes = method.getParameterTypes();
            System.out.print(parameterTypes.length + "parameters:");
            for (Class<?> paraType: parameterTypes){
                print("parameter smiple name: " + paraType.getSimpleName());
                System.out.print("parameter type name: " + paraType.getName());
                System.out.print("parameter modifier:" + Modifier.toString(paraType.getModifiers()));
                System.out.print(paraType.toGenericString());
            }
            Class<?>[] exceptionTypes = method.getExceptionTypes();
            System.out.print(exceptionTypes.length + "exception types:");
            for (Class<?> exceptionType: exceptionTypes) {
                System.out.print("exception name: " + exceptionType.getName());
                System.out.print("exception simple name: " + exceptionType.getSimpleName());
                System.out.print(exceptionType.toGenericString());
            }
            System.out.print("is accessible: " + method.isAccessible());
            System.out.print("is varArgs: " + method.isVarArgs());
        }

输出结果太多了，就是String类的所有可见方法，只弄一部分结果：
name:equals
defaultValue:null
generic return type:boolean
return type：boolean
modifiers:public
1parameters:
name:arg0
type:class java.lang.Object
1parameters:
parameter smiple name: Object
parameter type name: java.lang.Object
parameter modifier:public
public class java.lang.Object
0exception types:
is accessible: false
is varArgs: false

当然如果你想看不可见的方法，可以调用getDeclaredMethods()方法,
当然在获取一个方法对象后可以通过invoke(Object rescourse, Object…argument)方法调用,具体在invoke笔记中介绍。

6.构造器
我们可以通过类对象来获取该类的构造器

import java.lang.reflect.Constructor;

        Constructor<?>[] constructors = clz.getConstructors();
        for (Constructor<?> constructor: constructors) {
            System.out.println("constructor " + constructor.getName());
            System.out.println("number of parameters: " + constructor.getParameterCount());

            System.out.println("modifiers: " + Modifier.toString(constructor.getModifiers()));

            System.out.println(constructor.toGenericString());

            Annotation[] annotaitons = constructor.getAnnotations();

            for (Annotation annotation: annotaitons) {
                System.out.println(annotation.toString());
            }
            System.out.println();
        }

输出结果：
constructor java.lang.String
number of parameters: 3
modifiers: public
public java.lang.String(byte[],int,int)

constructor java.lang.String
number of parameters: 2
modifiers: public
public java.lang.String(byte[],java.nio.charset.Charset)

constructor java.lang.String
number of parameters: 2
modifiers: public
public java.lang.String(byte[],java.lang.String) throws java.io.UnsupportedEncodingException

constructor java.lang.String
number of parameters: 4
modifiers: public
public java.lang.String(byte[],int,int,java.nio.charset.Charset)

constructor java.lang.String
number of parameters: 4
modifiers: public
public java.lang.String(byte[],int,int,java.lang.String) throws java.io.UnsupportedEncodingException

constructor java.lang.String
number of parameters: 1
modifiers: public
public java.lang.String(java.lang.StringBuilder)

constructor java.lang.String
number of parameters: 2
modifiers: public
public java.lang.String(byte[],int)
@java.lang.Deprecated()

constructor java.lang.String
number of parameters: 4
modifiers: public
public java.lang.String(byte[],int,int,int)
@java.lang.Deprecated()

我仅仅保留了一部分结果，在代码中我要求输出可见的构造器的名字，参数，修饰类型，构造器的toGenericString()，以及构造器的注解，对于注解的含义在注解介绍笔记详细介绍，从结果看有@Deprecated注解，表示该方法被遗弃，不建议使用。

java反射机制的基础就像介绍在这里，后续将继续通过笔记介绍java反射的invoke，proxy代理等。
第一篇博客如有不足还请见谅，如有原理问题欢迎提出，共同学习。