Java反射

1、Java Reflection

• Reflection 是 Java被视为动态语言（运行时改变其结构）的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

• 加载完类之后，在对内存的方法去中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象地称之为：反射

正常方式创建对象：

• 引入需要的包的名称
• 通过new实例化
• 获得实例化对象

反射方式创建对象：

• 实例化对象
• getClass()方法
• 得到完整的包的名称

2、优缺点

• 可以实现动态创建对象和编译，体现出很大的灵活性
• 对性能有所影响

3、相关API

• java.lang.Class：代表一个类
• java.lang.reflect.Method：代表类的方法
• java.lang.reflect.Field：代表类的成员变量
• java.lang.reflect.Constructor：代表类的构造器

4、使用

通过反射创建对象

获取类的Class对象有三种方法

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过反射获取多个User类的Class对象，看其是否相等
        // 通过Class类的forName()方法来获得类的Class对象
        Class c1 = Class.forName("main.study.day4.User");
        // 通过类的class属性获得Class对象
        Class c2 = User.class;
        // 通过对象的getClass()方法获得Class对象
        Class c3 = new User().getClass();
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        c3.getClass();
    }
}

class User {
    private String name;
    private int age;

    public User() {
    }

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

    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;
    }
}

运行结果

1163157884
1163157884
1163157884

结论：可以看出，通过反射获取某个类的Class对象，获取的对象都是相同的。也就是每个类有且只有一个Class对象

Class类

Object类中定义以下方法

public final native Class<?> getClass();

这个方法的返回值就是Class类，Class类是反射的源头

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个 加载到JVM中的一个.class文件
• 每个类的实例都会记得自己是由哪个Class实例所生成
• 通过Class可以完整地得到一个类中的所有被加载的结构
• Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的对象

拥有Class对象的类型

class：外部类、内部内、静态内部类等
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

public class Demo3 {
   public static void main(String[] args) {
      Class c1 = Object.class;
      Class c2 = Collection.class;
      Class c3 = int[].class;
      Class c4 = ElementType.class;
      Class c5 = SuppressWarnings.class;
      Class c6 = Integer.class;
      Class c7 = void.class;
   }
}

通过反射获得类的信息

public class Demo4 {
   public static void main(String[] args) throws NoSuchMethodException, NoSuchFieldException, ClassNotFoundException {
      Class c1 = Class.forName("main.study.day4.User");

      // 获得所有公共属性
      Field[] fields = c1.getFields();

      // 获得所有属性
      Field[] declaredFields = c1.getDeclaredFields();

      // 获得指定属性
      Field name = c1.getDeclaredField("name");

      // 获得所有公有方法
      Method[] methods = c1.getMethods();

      // 获得所有方法
      Method[] declaredMethods = c1.getDeclaredMethods();

      // 获得指定方法
      Method setAge = c1.getDeclaredMethod("setAge", int.class);
   }
}

通过反射获得类的对象

通过newInstance()方法

• 类必须含有一个无参构造器
• 类的构造器的访问权限要足够

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      System.out.println(user);
   }
}

如果重载了一个方法的构造方法，最好再补上一个无参构造函数

通过获得类的构造器，再进行初始化

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class c1 = Class.forName("main.study.day4.User");
      Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
      User user2 = (User) constructor.newInstance("Nyima", 20);
      System.out.println(user2.getAge());
   }
}

总结：获得类的实例的步骤

• 通过类的Class对象
• 如果想通过调用无参构造方法创建实例
  • 直接调用Class对象的newInstance()方法
  • 将返回值强转为对应的类型
• 如果想通过有参构造方法创建实例
  • 调用Class对象的getDeclaredConstructor()并传入构造方法相应的参数的类型
  • 通过获得的有参构造器，调用newInstance()方法，传入相应参数
  • 将返回值强转为对应的类型

通过反射调用类的方法

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      Method setName = c1.getDeclaredMethod("setName", String.class);
      setName.invoke(user, "Nyima");
      System.out.println(user.getName());

   }
}

步骤

• 获得类的Class对象
• 调用Class对象的newInstance()方法，获取类的对象
• 调用Class对象的getDeclaredMethod()方法
• 调用返回对象的invoke()方法，传入所需的参数（参数包含对哪个对象调用该方法），如 setName.invoke(user, “Nyima”);

通过反射设置属性值

public class Demo5 {
   public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
      Class c1 = Class.forName("main.study.day4.User");
      User user = (User) c1.newInstance();
      Field name = c1.getDeclaredField("name");
      name.set(user, "Nyima2");
      System.out.println(user.getName());
   }
}

步骤

• 获得类的Class对象
• 调用Class对象的newInstance()方法，获取类的对象
• 调用Class对象的getDeclaredField()方法，获取属性
• 调用属性对象的set()方法进行赋值
  • 如果是私有属性，还需要调用name.setAccessible(true);方法进行设定

通过获得注解信息

public class Demo6 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("main.study.day4.Student");
        Student student = (Student) c1.newInstance();
        // 获得类的注解
        Annotation[] declaredAnnotations = c1.getDeclaredAnnotations();
        System.out.println(Arrays.toString(declaredAnnotations));

        // 获得属性上的注解
        Field name = c1.getDeclaredField("name");
        Annotation annotation = name.getAnnotation(FieldAnnotation.class);
        System.out.println(annotation);

        // 获得方法的注解
        Method getName = c1.getDeclaredMethod("getName");
        MethodAnnotation methodAnnotation = getName.getAnnotation(MethodAnnotation.class);
        System.out.println(methodAnnotation);
    }
}

@ClassAnnotation(name = "myStudent")
class Student {

    @FieldAnnotation(name = "name")
    private String name;
    @FieldAnnotation(name = "age")
    private int age;

    public Student() {
    }

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

    @MethodAnnotation(name = "getName")
    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;
    }
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 类的注解
 */
@interface ClassAnnotation {
    String name();
}

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 属性的注解
 */
@interface FieldAnnotation {
    String name();
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
/**
 * @author Nyima
 * 方法的注解
 */
@interface MethodAnnotation {
    String name();
}

步骤

• 先获取到对应的类，如
  • 想获得类注解，需要先获得Class类对象
  • 想获得属性的注解，需要先获得对应的属性
  • 想获得方法的注解，需要先获得对应的方法
  • …
• 通过对应的对象调用getDeclaredAnnotation()或者其他获取注解的方法，并传入需要的参数即可