java反射机制

3.2 反射

3.2.1 反射介绍

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制

简单的说:一个类有多个组成部分，例如：成员变量，方法，构造方法等。反射就是加载类，并解剖出类的各个组成部分

Java反射机制主要提供了以下功能：

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法；
• 在运行时调用任意一个对象的方法；生成动态代理

备注:程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言

3.2.2 反射的API介绍

Java反射所需要的类并不多，主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。
注意：Class类是Java反射的起源，针对任何一个你想探勘的类，只有先为它产生一个Class类的对象，接下来才能通过Class对象获取其他想要的信息。

1. Class类

• JVM为每种类型管理着一个独一无二的Class对象---每个类（型）都有一个Class对象
• Java程序运行过程中，当需要创建某个类的实例时，JVM首先检查所要加载的类对应的Class对象是否已经存在。如果还不存在，JVM就会根据类名查找对应的字节码文件并加载，接着创建对应的Class对象，最后才创建出这个类的实例。
• Java的基本数据类型都对应着一个Class对象；关键字void也都对应着一个Class对象；每个数组属性也被映射为 Class 对象，所有具有相同类型和维数的数组都共享该 Class 对象
  因此，运行中的类或接口在JVM中都会有一个对应的Class对象存在，它保存了对应类或接口的类型信息。要想获取类或接口的相应信息，需要先获取这个Class对象。

2. 加载类

• Java中有一个Class类用于代表某一个类的字节码
• Class类即然代表某个类的字节码，它当然就要提供加载某个类字节码的方法：forName()。forName方法用于加载某个类的字节码到内存中，并使用class对象进行封装
• 另外两种得到class对象的方式
  类名.class: Manager.class; int.class; double[].class;
  对象.getClass()

3. 解剖类

• Class对象提供了如下常用方法

      Public  Constructor  getConstructor(Class<?>... parameterTypes)
      Public  Method  getMethod(String name, Class<?>... parameterTypes) 
      Public  Field  getField(String name)   public
      public Constructor getDeclaredConstructor(Class... parameterTypes)
      public Method getDeclaredMethod(String name,Class... parameterTypes)
      public Field getDeclaredField(String name)  
  

这些方法分别用于从类中解剖出构造函数、方法和成员变量（属性）。解剖出的成员分别使用Constructor、 Method 、 Field 对象表示。

3.2.3 反射案例

案例5:Java反射案例

class Person {
      private int    age;
      private String name;

      public Person() {

      }

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

      public int getAge() {
                return age;
      }

      public void setAge(int age) {
                this.age = age;
      }

      public String getName() {
                return name;
      }

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

interface ActionInterface {
      public void walk(int m);
}   

class SuperMan extends Person implements ActionInterface {
      private boolean blueBriefs;

      public void fly() {
                System.out.println("超人会飞耶～～");
      }

      public boolean isBlueBriefs() {
                return blueBriefs;
      }

      public void setBlueBriefs(boolean blueBriefs) {
                this.blueBriefs = blueBriefs;
      }

      @Override
      public void walk(int m) {
                System.out.println("超人会走耶～～走了" + m + "米就走不动了！");
      }
}

示例1：通过Java反射机制得到类的包名和类名

public static void main(String[] args){
    Person person = new Person();
    System.out.println("包名：" + person.getClass().getPackage().getName());
    System.out.println("完整类名：" + person.getClass().getName());
}

示例2：验证所有的类都是Class类的实例对象

public static void main(String[] args){
    // 定义两个类型都未知的Class，设置初值为null，看看如何给它们赋值成Person类
    Class<?> class1 = null;
    Class<?> class2 = null;
    // 写法1，可能抛出 ClassNotFoundException 异常，多用这个写法
    try {
            class1 = Class.forName("shuang.com.demo.Person");//包名要写正确，不然抛异常
            System.out.println("写法1，包名：" + class1.getPackage().getName() + " , 完整类名：" + class1.getName());
    } catch (ClassNotFoundException e) {
            System.out.println("写法1找不到类");
    }
    // 写法2
    class2 = Person.class;
    System.out.println("写法2，包名：" + class2.getPackage().getName() + " , 完整类名：" + class2.getName());
 }

示例3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
    Class<?> class1 = null;
    class1 = Class.forName("shuang.com.demo.Person");
    // 由于这里不能带参数，所以你要实例化的这个类Person，一定要有无参构造函数
    Person person = (Person) class1.newInstance();
    person.setName("xiaoming");
    person.setAge(20);
    System.out.println(person.getName() + " , " + person.getAge());
}

示例4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException,IllegalArgumentException, InvocationTargetException{
    Class<?> class1 = null;
    Person person1 = null;
    Person person2 = null;
    class1 = Class.forName("shuang.com.demo.Person");
    Constructor<?>[] constructors = class1.getConstructors();
    person1 = (Person) constructors[0].newInstance();
    person1.setName("xiaoming");
    person1.setAge(20);
    System.out.println(person1.getName() + " , " + person1.getAge());
    person2 = (Person) constructors[1].newInstance(21, "xiaohong");
    System.out.println(person2.getName() + " , " + person2.getAge());
}

示例5：通过Java反射机制操作成员变量, set 和 get

public static void main(String args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, SecurityException{
    Class<?> class1 = Class.forName("shuang.com.demo.Person");
    Object obj = class1.newInstance();
    Field personNameField = class1.getDeclaredField("name");
    personNameField.setAccessible(true); // 取消访问检查
    personNameField.set(obj, "小虎");
    System.out.println("修改属性之后得到属性变量的值：" + personNameField.get(obj));
}

示例6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等

public static void main(String[] args) throws ClassNotFoundException{
    Class<?> class1 = Class.forName("shuang.com.demo.SuperMan");

    // 取得父类名称
    Class<?> superclass = class1.getSuperclass();
    System.out.println("SuperMan类的父类名：" + superclass.getName());

    Field[] fields = class1.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
              System.out.println("类中的成员" + i + "： " + fields[i]);
    }

    // 取得类方法
    Method[] methods = class1.getDeclaredMethods();
    for (int i = 0; i < methods.length; i++) {
              System.out.println("取得SuperMan类的方法" + i + "：");
              System.out.println("函数名：" + methods[i].getName());
              System.out.println("函数返回类型：" + methods[i].getReturnType());
              System.out.println("函数访问修饰符：" + Modifier.toString(methods[i].getModifiers()));
              System.out.println("函数代码写法： " + methods[i]);
    }

    // 取得类实现的接口，因为接口类也属于Class，所以得到接口中的方法也是一样的方法得到哈
    Class<?> interfaces[] = class1.getInterfaces();
    for (int i = 0; i < interfaces.length; i++) {
              System.out.println("实现的接口类名： " + interfaces[i].getName());
    }
}

示例7：通过Java反射机制调用类方法

public static void main(String[] args)throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,InstantiationException, InvocationTargetException{
    Class<?> class1 = Class.forName("shuang.com.demo.SuperMan");

    System.out.println("调用无参方法fly()：");
    Method method = class1.getMethod("fly");
    method.invoke(class1.newInstance());

    System.out.println("调用有参方法walk(int m)：");
    method = class1.getMethod("walk", int.class);
    method.invoke(class1.newInstance(), 100);
}