什么是反射

概述
    java万物皆对象。一个类首先由类加载器加载类文件（class文件），类加载器把class文件的内容读取出来封装成不同的对象。
    例如Class类，Method类，Constructor类，Field类,通过这些类文件的对象可以读取类的相关信息，甚至构造类的实例，调用类的方法，这就是反射！！！
要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。
API
    Class
        代表一个类
    Constructor
        代表一个构造方法
    Method
        代表一个普通方法
    Field
        代表一个属性
优点
    提高了Java程序的灵活性和扩展性，降低了耦合性，提高自适应能力
缺点
    反射会模糊程序内部逻辑，可读性较差
应用
    反射机制主要应用在对灵活性和扩展性要求很高的系统框架上
    如软件测试、 EJB、JavaBean等
    开源框架例如Struts、Hibernate、Spring

反射的作用

动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。

反射的应用场景

数据库操作
框架

获取Class对象

Class clazz = Class.forName("com.shuai.test.Student");
Class clazz = Student.class;
Class clazz = new Student().getClass();

获取属性

Class clazz = Class.forName("com.shuai.test.Student");
//获取public的属性,本类和父类和父接口中的public属性。只能是public修饰的属性
Field field = clazz.getField("name");
System.out.println(field.getName());
////获取public的属性,本类和父类和父接口中的public属性。只能是public修饰的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
    System.out.println(f.getName());
}
//可以获得所有访问修饰符修饰的属性,只能是本类中的属性，并且不能是继承和实现的类中的属性。
Field field2 = clazz.getDeclaredField("test");
System.out.println(field2.getName());
//可以获得所有访问修饰符修饰的属性,只能是本类中的属性，并且不能是继承和实现的类中的属性。
Field[] fields2 = clazz.getDeclaredFields();
for(Field f : fields2){
    System.out.println(f.getName());
}

5.获取方法

Class clazz = Class.forName("com.shuai.test.Student");
//获取public的某个方法，只能是public。可以是本类，父类。
//从第二个参数开始是方法的形参类型，按照顺序填写。无参就是null。有参按照顺序填写，或者填写一个数组。
Method method = clazz.getMethod("getName", null);
System.out.println(method.getName());
//获取所有的public方法，只能是public。可以是本类，父类。
Method[] methods = clazz.getMethods();
for(Method m : methods){
    System.out.println(m.getName());
}
//获取本类所有访问修饰符修饰的某个方法，只能是本类。
Method method2 = clazz.getDeclaredMethod("setName", String.class);
System.out.println(method2.getName());
//获取本类所有访问修饰符修饰的方法，只能是本类。
Method[] methods2 = clazz.getDeclaredMethods();
for(Method m : methods2){
    System.out.println(m.getName());
}

6.获取构造

Class clazz = Class.forName("com.shuai.test.Student");
//获得本类的public修饰的无参构造
Constructor constructor = clazz.getConstructor(null);
System.out.println(constructor.getName());
//获得本类中的public修饰的有参构造，这里的参数可以连续传多个，也可以直接传一个数组
Constructor constructor3 = clazz.getConstructor(String.class);
System.out.println(constructor3.getName());
//获得本类中的所有构造
Constructor[] constructors = clazz.getConstructors();
for(Constructor c:constructors){
    System.out.println(c.getName());
}
//获得本类中的所有被任意修饰符修饰的无参构造
Constructor constructor2 = clazz.getDeclaredConstructor(null);
System.out.println(constructor2.getName());
//获得本类中的所有被任意修饰符修饰的有参构造，这里的参数可以连续传多个，也可以直接传一个数组
Constructor constructor4 = clazz.getDeclaredConstructor(String.class);
System.out.println(constructor4.getName());
//获得本类中的所有被任意修饰符修饰的构造
Constructor[] constructors2 = clazz.getDeclaredConstructors();
for(Constructor c:constructors2){
    System.out.println(c.getName());
}

7.创建对象

Class clazz = Class.forName("com.shuai.test.Student");
//调用无参构造创建对象
Object object = clazz.newInstance();
//调用无参构造创建对象
Constructor constructor = clazz.getConstructor(null);
Object object2 = constructor.newInstance(null);
//调用指定的有参构造创建对象
Constructor constructor2 = clazz.getConstructor(String.class);
Object object3 = constructor2.newInstance("shuaige");

8.调用public方法赋值/取值

Class clazz = Class.forName("com.shuai.test.Student");
//调用无参构造创建对象
Object object = clazz.newInstance();
// 赋值
Method method = clazz.getMethod("setName",String.class);
method.invoke(object, "shuaige");
//第二种
Field field = clazz.getField("name");
field.set(object, "shuaige");
// 取值
Method method2 = clazz.getMethod("getName", null);
Object object2 = method2.invoke(object, null);

9.调用任意访问修饰符修饰的方法赋值取值

Class clazz = Class.forName("com.shuai.test.Student");
Object object = clazz.newInstance();
Method method = clazz.getDeclaredMethod("setName", String.class);
method.setAccessible(true);
method.invoke(object, "shuaige");
Method method2 = clazz.getDeclaredMethod("getName",null);
method2.setAccessible(true);
Object object2 = method2.invoke(object, null);
System.out.println(object2);

10.获取RUNTIME类型的注解

Class clazz = Class.forName("com.shuai.test.Student");
// 获取RUNTIME类型的注解
Method[] methods = clazz.getMethods();
for(Method method : methods){
    Annotation[] annotations = method.getAnnotations();
    Annotation[] annotations2 = method.getDeclaredAnnotations();
}

11.是不是一个接口

Class clazz = Class.forName("com.shuai.test.IStudy");
// 是不是一个接口
boolean interface1 = clazz.isInterface();
System.out.println(interface1);

12.是不是一个枚举

Class clazz = Class.forName("com.shuai.test.Gender");
// 是不是一个枚举
boolean enum1 = clazz.isEnum();
System.out.println(enum1);

13.是不是一个抽象类

Class clazz = Class.forName("com.shuai.test.Student");
boolean abstract1 = Modifier.isAbstract(clazz.getModifiers());
System.out.println(abstract1);

14.获取包名

Class clazz = Class.forName("com.shuai.test.Student");
Package package1 = clazz.getPackage();
System.out.println(package1.getName());

15.获取枚举类中的值

Class clazz = Class.forName("com.shuai.test.Gender");
Object[] constants = clazz.getEnumConstants();
for(Object obj : constants){
    System.out.println(obj);
}

16.获取父类

Class clazz = Class.forName("com.shuai.test.Student");
Class superclass = clazz.getSuperclass();
System.out.println(superclass.getName());

17.获取接口

Class clazz = Class.forName("com.shuai.test.Student");
Class[] interfaces = clazz.getInterfaces();

18.获取内部类

Class clazz = Class.forName("com.shuai.test.Student");
//获得public的内部类,本类或者父类中的
Class[] classes = clazz.getClasses();
//获得本类中被任意修饰符修饰的内部类
Class[] classes2 = clazz.getDeclaredClasses();

19.获取外部类

Class clazz = Class.forName("com.shuai.test.Student$AAA");
Class declaringClass = clazz.getDeclaringClass();
System.out.println(declaringClass.getName());

获得类名getSimpleName

Class clazz = Class.forName("com.shuai.test.Student$AAA");
Class declaringClass = clazz.getDeclaringClass();
System.out.println(declaringClass.getSimpleName());

是否是该类型的实例

Class clazz = Class.forName("com.shuai.test.Student");
Object newInstance = clazz.newInstance();
boolean instance = clazz.isInstance(newInstance);
System.out.println(instance);

获取父类泛型

举例：public class StudentDao extends BaseDao<Student>{}
//得到具体的Dao类
Class daoClass = this.getClass();
//得到Dao类上的泛型父类(参数化类型:带有泛型的类型)- BaseDao<Student>
Type type = daoClass.getGenericSuperclass();
//强制转换为参数化类型(使用参数化类型的方法)
ParameterizedType paramType = (ParameterizedType)type;
//得到参数化类型中的具体的泛型类型<Student>
Type[] types = paramType.getActualTypeArguments();
Class clazz = (Class)types[0];

获得类型

Class daoClass = this.getClass();
String name = daoClass.getSimpleName();