/** 获取Class实例的三种方式 **/
public static void getClassInstance()throws Exception{
        // 方式1:直接通过类名获取Class实例
        System.out.println("根据类名获取Class实例:"+Test.class);
        // 方式2:通过类对象的getClass()获取Class实例
        System.out.println("类对象的getClass()获取Class实例:"+new Test().getClass());
        // 方式3:通过Class.forName()根据全限定类名反射方式获取Class实例
        System.out.println("Class.forName()根据全限定类名获取Class实例:"
            +Class.forName("reflect.Test"));
}

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectExample {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException {
        // 获取Class实例
        Class<Dog> cls = Dog.class;
        // 返回Class的全限定类名
        System.out.println(cls.getName()); // reflect.Dog
        // 返回Class的类名(不包含包名)
        System.out.println(cls.getSimpleName()); // Dog
        // 返回Class的类型名称(包含包名和类名)
        System.out.println(cls.getTypeName()); // reflect.Dog
        // 返回Class所在包的名称
        System.out.println(cls.getPackage().getName()); // reflect

        // 创建类的新实例
        Dog dog = cls.newInstance();
        dog.setName("大黄");
        System.out.println(dog.getName()); // "大黄"
        // 获取Class实现的接口列表,返回一个Class数组
        Class<?>[] interfaces = cls.getInterfaces();
        Arrays.stream(interfaces).forEach(i->System.out.print(i.getName()+" ")); // java.io.Serializable
        System.out.println();

        // 获取Class中非private修饰的构造函数,返回一个Constructor数组
        Constructor<?>[] constructors01 = cls.getConstructors();
        Arrays.stream(constructors01).forEach(i->System.out.print(i.getName()+" ")); // reflect.Dog reflect.Dog
        System.out.println();

        // 获取Class中所有构造函数,返回一个Constructor数组
        Constructor<?>[] constructors02 = cls.getDeclaredConstructors();
        Arrays.stream(constructors02).forEach(i->System.out.print(i.getName()+" ")); // reflect.Dog reflect.Dog reflect.Dog
        System.out.println();

        // 获取Class中非private修饰的方法,返回一个Method数组(包括从父类继承的方法)
        Method[] methods01 = cls.getMethods();
        Arrays.stream(methods01).forEach(i->System.out.print(i.getName()+" ")); // getAge setAge getName setName eat wait wait wait equals toString hashCode getClass notify notifyAll
        System.out.println();

        // 获取Class中所有的方法,返回一个Method数组
        Method[] methods02 = cls.getDeclaredMethods();
        Arrays.stream(methods02).forEach(i->System.out.print(i.getName()+" ")); // getAge setAge getName setName getName
        System.out.println();
        // 根据方法名和方法参数的类型获取Method
        Method method = cls.getDeclaredMethod("setName",String.class);
        System.out.println(method.getName()); // setName

        // 获取当前Class的类加载器
        System.out.println(cls.getClassLoader()); // sun.misc.Launcher$AppClassLoader@18b4aac2
        // 获取当前Class的父类
        Class<? super Dog> superclass = cls.getSuperclass();
        System.out.println(superclass.getName()); // reflect.Animal

        // 判断当前Class是否是一个Annotation
        System.out.println(cls.isAnnotation()); // false
        // 判断当前Class是否是interface
        System.out.println(cls.isInterface()); // false
        // 判断当前Class是否是枚举类
        System.out.println(cls.isEnum()); // false
        // 判断当前Class是否是数组类
        System.out.println(cls.isArray()); // false
    }
}

package reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;
import java.util.Arrays;

public class ReflectExample {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException {
        Class<Dog> cls = Dog.class;
        // 获取Class中所有构造方法,返回一个Constructor数组
        Constructor<?>[] cts = cls.getDeclaredConstructors();
        // 根据构造方法参数的类型从Class获取Constructor,注意构造方法参数的类型需要是包装类型
        Constructor<Dog> ct = cls.getDeclaredConstructor(String.class,Integer.class);
        // 获取构造方法名称
        System.out.println(ct.getName()); // reflect.Dog
        // 获取构造方法修饰符
        System.out.println(ct.getModifiers()); // 1
        // 获取构造方法的参数数量
        System.out.println(ct.getParameterCount()); // 2
        // 获取构造方法的参数类型,返回一个Class数组
        Class<?>[] parameterTypes = ct.getParameterTypes();
        Arrays.stream(parameterTypes).forEach(i->System.out.print(i.getName()+" ")); // java.lang.String java.lang.Integer
        System.out.println();
        // 获取构造方法的参数,返回一个Parameter数组
        Parameter[] parameters = ct.getParameters();
        Arrays.stream(parameters).forEach(i->System.out.print(i.getName()+" ")); // arg0 arg1
        System.out.println();
        // 判断构造方法是否存在指定注解
        System.out.println(ct.isAnnotationPresent(Deprecated.class)); // true
    }
}

package reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.Arrays;

public class ReflectExample {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class<Dog> cls = Dog.class;
        // 获取Class中所有的Method
        Method[] methods = cls.getDeclaredMethods();
        Arrays.stream(methods).forEach(i-> System.out.print(i.getName()+" ")); // getAge setAge getName setName
        System.out.println();

        // 根据方法名和方法参数的类型从Class中获取Method
        Method method = cls.getDeclaredMethod("setName", String.class);
        // 获取Method的修饰符
        System.out.println(method.getModifiers()); // 1
        // 获取Method的返回值类型
        System.out.println(method.getReturnType().getName()); // void
        // 获取Method的参数数量
        System.out.println(method.getParameterCount()); // 1
        // 获取Method的参数列表,返回一个Parameter数组
        Parameter[] parameters = method.getParameters();
        Arrays.stream(parameters).forEach(i-> System.out.print(i.getName()+" ")); // arg0
        System.out.println();
        // 获取Method的参数类型,返回一个Class数组
        Class<?>[] parameterTypes = method.getParameterTypes();
        Arrays.stream(parameterTypes).forEach(i-> System.out.print(i.getName()+" ")); // java.lang.String
        System.out.println();
        // 获取Method上的注解,返回一个Annotation数组
        Annotation[] annotations = method.getAnnotations();
        Arrays.stream(annotations).forEach(i-> System.out.print(i.toString()+" ")); // @java.lang.Deprecated()
        System.out.println();

        // 判断当前Method是否是默认方法
        System.out.println(method.isDefault()); // false
        // 判断方法是否可访问,返回一个布尔值。可通过Method的setAccessible()设置访问性
        System.out.println(method.isAccessible()); // false
        // 判断当前方法是否包含指定注解
        System.out.println(method.isAnnotationPresent(Deprecated.class)); // true

        Dog dog = cls.newInstance();
        // 调用方法,第一个参数为方法中的 this(一般是Method所在类的实例),第二个参数为方法的参数
        method.invoke(dog,"大黄");
        System.out.println(dog.getName()); // 大黄
    }
}

package reflect;

import java.lang.reflect.Field;
import java.util.Arrays;

public class ReflectExample {
    public static void main(String[] args) throws NoSuchFieldException, InstantiationException, IllegalAccessException {
        Class<Dog> cls = Dog.class;
        // 获取Class中所有的Field
        Field[] fields = cls.getDeclaredFields();
        Arrays.stream(fields).forEach(i-> System.out.print(i.getName()+" ")); // name age address
        System.out.println();
        // 根据字段名称从Class中获取Field
        Field field = cls.getDeclaredField("name");
        // 获取字段名称
        System.out.println(field.getName()); // name
        // 获取字段修饰符
        System.out.println(field.getModifiers()); // 2
        // 获取字段类型,返回一个Class对象
        System.out.println(field.getType().getName()); // java.lang.String
        // 获取字段所属类字段,返回一个Class对象
        System.out.println(field.getDeclaringClass().getName()); // reflect.Dog

        Dog dog = cls.newInstance();
        dog.setName("大黄");
        // 设置字段访问性
        field.setAccessible(true);
        // 根据对象获取对应字段(Field)的值,返回一个 Object,访问前需要设置字段的访问性
        System.out.println(field.get(dog)); // 大黄
        // 判断字段是否可访问,返回一个布尔值。可通过Field类的setAccessible()设置访问性。
        System.out.println(field.isAccessible()); // true
        // 判断字段是否是一个枚举常量,返回一个布尔值
        System.out.println(field.isEnumConstant()); // false
        // 判断字段是否包含指定注解
        System.out.println(field.isAnnotationPresent(Deprecated.class)); // false
    }
}

// 0x00000001 表示public修饰符
public static final int PUBLIC           = 0x00000001;
// 0x00000002 表示private修饰符
public static final int PRIVATE          = 0x00000002;
// 0x00000004 表示protected修饰符
public static final int PROTECTED        = 0x00000004;
// 0x00000008 表示static修饰符
public static final int STATIC           = 0x00000008;
// 0x00000010 表示final修饰符
public static final int FINAL            = 0x00000010;
// 0x00000020 表示synchronized修饰符
public static final int SYNCHRONIZED     = 0x00000020;
// 0x00000040 表示volatile修饰符
public static final int VOLATILE         = 0x00000040;
// 0x00000080 表示transient修饰符
public static final int TRANSIENT        = 0x00000080;
// 0x00000100 表示native修饰符
public static final int NATIVE           = 0x00000100;
// 0x00000200 表示interface修饰符
public static final int INTERFACE        = 0x00000200;
// 0x00000400 表示abstract修饰符
public static final int ABSTRACT         = 0x00000400;
// 0x00000800 表示strict修饰符
public static final int STRICT           = 0x00000800;
// 0x00000040 表示bridge(桥接)修饰符
static final int BRIDGE    = 0x00000040;
// 0x00000080 表示varargs(可变变量)修饰符
static final int VARARGS   = 0x00000080;
// 0x00001000 表示synthetic(合成)修饰符
static final int SYNTHETIC = 0x00001000;
// 0x00002000 表示annotation(注解)修饰符
static final int ANNOTATION  = 0x00002000;
// 0x00004000 表示enum(枚举)修饰符
static final int ENUM      = 0x00004000;
// 0x00008000 表示mandated(委托)修饰符
static final int MANDATED  = 0x00008000;