1.反射的定义
动态语言
动态语言是指在运行阶段可以改变其结构
Java、C++、C是静态语言，Java可以通过反射获得类似动态语言的特性。
反射
反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
对比
正常方式和反射方式的对比
反射的优缺点
- 优点：可以动态创建对象和编译，灵活
- 缺点： 对象性能有影响，总是慢于直接执行相同的操作
2.Class类
2.1 什么是Class类
- class本身也是一个类
- 只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class实例对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个class实例生成的
- 通过Class可以完整的得到一个类所有被加载的结构
- Class类是Reflection反射的根源，针对任何想动态加载，运行的类，唯有先获得相应的Class对象
2.2 获取Class类的方法
1) 通过对象获得
Class c1 = person.getClass();
2) forName获得
Class c2 = Class.forName("com.mouweng.Student");
3) 通过类名.class获得
Class c3 = Student.class;
4) 包装类Type属性
Class c4 = Integer.TYPE;
5) 获得父类类型
Class c5 = c1.getSuperclass();
2.3 哪些类型有Class
类、接口、一维数组、二维数组、注解、枚举、基本数据类型、void、Class
只要元素类型一样，就是同一个Class
3.获取类运行时的结构
3.1 获取类的名字
Class c1 = Class.forName("com.mouweng.User");
// 获得类的名字
System.out.println(c1.getName());
System.out.println(c1.getSimpleName());
3.2 类的属性
Class c1 = Class.forName("com.mouweng.User");
// 获得类的属性
Field[] fields = c1.getFields();// 只能找到public属性
for (Field field : fields) {
System.out.println(field);
}
System.out.println();
fields = c1.getDeclaredFields();// 找到全部的属性
for (Field field : fields) {
System.out.println(field);
}
System.out.println();
// 获得指定类的属性的值
Field field = c1.getDeclaredField("name");
System.out.println(field);
3.3 类的方法
Class c1 = Class.forName("com.mouweng.User");
// 获得方法
Method[] methods = c1.getMethods();
for (Method method : methods) {
System.out.println("正常的：" + method); // 获得本类及其父类的全部public方法
}
System.out.println();
methods = c1.getDeclaredMethods();// 获得本类的所有方法
for (Method method : methods) {
System.out.println("getDeclaredMethods :" + method);
}
System.out.println();
// 获得指定的方法
// 要丢参数进去，方法有重载
Method method1 = c1.getMethod("getName",null);
Method method2 = c1.getMethod("setName", String.class);
System.out.println(method1);
System.out.println(method2);
3.4 类的构造器
Class c1 = Class.forName("com.mouweng.User");
// 获得指定的构造器
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println();
Constructor constructor1 = c1.getConstructor(null);
System.out.println(constructor1);
Constructor constructor2 = c1.getConstructor(String.class,int.class,int.class);
System.out.println(constructor2);
4.动态创建对象执行方法
4.1 newInstance方法
（1）必须要有默认的无参构造才行
（2）类的构造器能被访问
Class c1 = Class.forName("com.mouweng.User");
User user = (User)c1.newInstance();// 本质上调用类的无参构造器
System.out.println(user);
4.2 通过构造器创建对象
获取构造器，通过构造器进行传参创建对象
// 通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
User user2 = (User) constructor.newInstance("某翁", 001, 18);
System.out.println(user2);
4.3 通过反射调用普通方法
通过invoke调用指定的方法
// 通过反射调用普通方法
User user3 = (User) c1.newInstance();
// 通过反射获取方法
Method setName = c1.getDeclaredMethod("setName",String.class);
// invoke : 激活的意思,调用了set方法(对象，"方法的值")
setName.invoke(user3,"yifan");
System.out.println(user3);
4.4 通过反射操作属性
setAccessible设置取消安全检测
// 通过反射操作属性
User user4 = (User) c1.newInstance();
Field name = c1.getDeclaredField("name");// 不能直接操作私有属性
// 因为是私有属性，设置取消安全检测
name.setAccessible(true);
name.set(user4, "fanfan");
System.out.println(user4);
5.反射操作范型
public class Test07 {
public void test01(Map<String, User> map, List<User> list) {
System.out.println("test01");
}
public Map<String, User> test02() {
System.out.println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
// 获取参数列表的范型
Method method = Test07.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
System.out.println(genericParameterType);
}
// 获取返回的范型
method = Test07.class.getMethod("test02",null);
Type genericReturnType = method.getGenericReturnType();
System.out.println(genericReturnType);
}
}
6.反射获取注解
可以通过反射来获取注解，对注解进行解析，得到相关信息！
package com.mouweng;
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test08 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("com.mouweng.student");
// 通过反射来获得注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations) {
//找到了外面的注解@com.mouweng.TableTemp(value=db_stu)
System.out.println(annotation);
}
//获得注解的值 db_stu
TableTemp tableTemp = (TableTemp)c1.getAnnotation(TableTemp.class);
String value = tableTemp.value();
System.out.println(value);
// 获得类的指定的注解
Field field = c1.getDeclaredField("name");
FieldTemp annotation = field.getAnnotation(FieldTemp.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableTemp("db_stu")
class student{
@FieldTemp(columnName = "db_id", type = "int", length = 10)
private int id;
@FieldTemp(columnName = "db_name", type = "varchar", length = 20)
private String name;
@FieldTemp(columnName = "db_age", type = "int", length = 10)
private int age;
public student() {
}
public student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 类名的注解
@Target(ElementType.TYPE)//设置作用域
@Retention(RetentionPolicy.RUNTIME)//设置什么级别可以获取
@interface TableTemp{
String value();
}
// 属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldTemp{
String columnName();//列名的注解
String type();//类型
int length();//长度
}
