参考文章：
//www.greatytc.com/p/607ff4e79a13
https://juejin.im/post/6844903776873086989#heading-32
练习源码

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;

/**
 * Member
 * java.lang.reflect.Field ：对应类变量
 * java.lang.reflect.Method ：对应类方法
 * java.lang.reflect.Constructor ：对应类构造函数
 *
 *
 * AccessibleObject
 * java.lang.reflect.Method :成员方法,静态方法
 * java.lang.reflect.Constructor :构造方法
 */
public class TestReflect {

    public static void main(String[] args) {
        Class c = null;
        Object obj = null;
        try {
            c = Class.forName("com.example.wifi.Reflect.Cat");
            obj = c.getConstructor(String.class, int.class).newInstance("短歌短歌", 1);

            /**
             * 1,属性:变量,静态变量,静态常量
             * getDeclaredField(String name)
             * 获取指定的变量（只要是声明的变量都能获得，包括private）
             * getField(String name)
             * 获取指定的变量（只能获得public的）
             * getDeclaredFields()
             * 获取所有声明的变量（包括private）
             * getFields()
             * 获取所有的public变量
             */
            //name
            Field fieldName = c.getDeclaredField("name");
            fieldName.setAccessible(true);//可以访问private修改的变量
            String name = (String) fieldName.get(obj);
            System.out.println("name : " + name);
            fieldName.set(obj, "富力东方");
            String name2 = (String) fieldName.get(obj);
            System.out.println("name : " + name2);
            //TAG1
            Field fieldTAG1 = c.getDeclaredField("TAG1");
            fieldTAG1.setAccessible(true);
            String TAG1 = (String) fieldTAG1.get(null);
            System.out.println("TAG1 : " + TAG1);
            //TAG2
            Field fieldTAG2 = c.getDeclaredField("TAG2");
            fieldTAG2.setAccessible(true);
            String TAG2 = (String) fieldTAG2.get(obj);
            System.out.println("TAG2 : " + TAG2);


            /**
             * 2,Method
             * getDeclaredMethod(String name, Class<?>... parameterTypes)
             * 根据方法名获得指定的方法， 参数name为方法名，参数parameterTypes为方法的参数类型，如 getDeclaredMethod(“eat”, String.class)
             * getMethod(String name, Class<?>... parameterTypes)
             * 根据方法名获取指定的public方法，其它同上
             * getDeclaredMethods()
             * 获取所有声明的方法
             * getMethods()
             * 获取所有的public方法
             */
            //静态方法
            Method methodGetTAG = c.getDeclaredMethod("getTAG");
            methodGetTAG.setAccessible(true);
            String result = (String) methodGetTAG.invoke(null);
            System.out.println("getTAG : " + result);
            //成员方法
            Method methodSetName = c.getDeclaredMethod("setName", String.class);
            methodSetName.invoke(obj, "猜猜我是谁");
            Method methodGetName = c.getDeclaredMethod("getName");
            String getName = (String) methodGetName.invoke(obj);
            System.out.println("getName : " + getName);
            //3,获取方法的返回值的class和taype
            Class classReturnType = methodGetName.getReturnType();
            Type getGenericReturnType = methodGetName.getGenericReturnType();

            //方法参数的class和type的数组.
            Class[] getDeclaringClass = methodSetName.getParameterTypes();
            Type[] getParameterTypes = methodSetName.getGenericParameterTypes();

            //获取方法参数相关信息
            Parameter[] getParameters = methodSetName.getParameters();
            for (int i = 0; i < getParameters.length; i++) {
                Parameter p = getParameters[i];
                p.getType();   //获取参数类型
                p.getName();  //获取参数名称，如果编译时未加上`-parameters`，返回的名称形如`argX`, X为参数在方法声明中的位置，从0开始
                p.getModifiers(); //获取参数修饰符
                p.isNamePresent();  //.class文件中是否保存参数名称, 编译时加上`-parameters`返回true,反之flase
            }
            System.out.println("是否是可变参数"+methodSetName.isVarArgs()); //判断方法参数是否是可变参数
            System.out.println("是否是复合方法"+methodSetName.isSynthetic()); //判断是否是复合方法，个人理解复合方法是编译期间编译器生成的方法，并不是源代码中有的方法
            System.out.println("是否是桥接方法"+methodSetName.isBridge());  //判断是否是桥接方法，桥接方法是 JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法。可以参考


            //调用定项参数方法
            Method eat = c.getDeclaredMethod("eat", String.class);
            eat.invoke(obj, "grass");
            //调用不定项参数方法
            //不定项参数可以当成数组来处理
            Class[] argTypes = new Class[] { String[].class };
            Method varargsEat = c.getDeclaredMethod("eat", argTypes);
            String[] foods = new String[]{
                    "grass", "meat","苹果","白菜"
            };
            varargsEat.invoke(obj, (Object)foods);


            /**
             * 3,构造方法
             * getDeclaredConstructor(Class<?>... parameterTypes)
             * 获取指定构造函数，参数parameterTypes为构造方法的参数类型
             * getConstructor(Class<?>... parameterTypes)
             * 获取指定public构造函数，参数parameterTypes为构造方法的参数类型
             * getDeclaredConstructors()
             * 获取所有声明的构造方法
             * getConstructors()
             * 获取所有的public构造方法
             */
            Constructor constructor = c.getDeclaredConstructor(String.class);//获取私有构造方法
            constructor.setAccessible(true);
            Animal cat = (Cat) constructor.newInstance("只有一个");
            System.out.println("获取名字"+cat.toString());

            /**
             * 4,数组
             */

            Field field = c.getDeclaredField("arryInt");
            field.setAccessible(true);
            //获取一个变量的类型
            Class<?> cArray = field.getType();
            //判断该变量是否为数组
            if (cArray.isArray()) {
                //获取数组的元素类型
                int[] array = (int[]) field.get(obj);
                for (int i = 0; i < array.length; i++) {
                    System.out.println(Array.get(array, i));//读取下标bai2数组du元素zhi
                }
            }

            /**
             * 5,枚举
             */
            Class classEnum = Class.forName("com.example.wifi.Reflect.StatuEnum");
            if (classEnum.isEnum()) {
                Object[] objectEnum = classEnum.getEnumConstants();
                for (int i = 0; i < objectEnum.length; i++) {
                    System.out.println("枚举="+objectEnum[i]);
                    System.out.println("枚举值="+((StatuEnum)objectEnum[i]).s);
                }
            }


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

//父类
public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal : name = " + name + " age = " + age;
    }
}

//反射获取的对象类
import java.io.Serializable;
class Cat extends Animal implements Serializable {
    private static final String TAG = Cat.class.getSimpleName();

    private static String TAG1 = Cat.class.getName();

    private final String TAG2 = "lalala";

    private int[] arryInt = {1, 2, 3, 4, 5, 6};

    private String name;

    private int i = new Integer(10);

    @Deprecated
    public int age;

    public Cat() {
        super("", 0);
    }

    private Cat(String name) {
        super(name, 0);
        this.name = name;
    }

    public Cat(String name, int age) {
        super(name, age);
        this.name = name;
        this.age = age;
    }

    public void setName(String names) {
        this.name = names;
    }

    public String getName() {
        return name;
    }

    public void eat(String food) {
        System.out.println(TAG + "eat food " + food);
    }

    public void eat(String... foods) {
        StringBuilder s = new StringBuilder();
        for (String food : foods) {
            s.append(food);
            s.append(" ");
        }
        System.out.println(TAG + "eat food " + s.toString());
    }

    public void sleep() {
        System.out.println(TAG + "sleep");
    }


    private static  String getTAG() {
        return TAG;
    }

    @Override
    public String toString() {
        return "name = " + name + " age = " + age;
    }
}

//枚举
public enum StatuEnum {
    START("start"), STOP("stop"), DESTROY("destroy");

    StatuEnum(String s) {
        this.s = s;
    }

    String s;
}