03-3-2Java反射

1Java反射机制概述

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

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

正常方式：引入需要的”包类”名称 ->通过new实例化 ->取得实例化对象

反射方式：实例化对象 ->getClass()方法 ->得到完整的“包类”名称

1.1动态语音和静态语言

1、动态语言

是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。

2、静态语言

与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

1.2java反射机制提供的功能

• 在运行时判断任意一个对象所属的类

• 在运行时构造任意一个类的对象

• 在运行时判断任意一个类所具有的成员变量和方法

• 在运行时获取泛型信息

• 在运行时调用任意一个对象的成员变量和方法

• 在运行时处理注解

• 生成动态代理

1.3反射相关api

• java.lang.Class:代表一个类

• java.lang.reflect.Method:代表类的方法

• java.lang.reflect.Field:代表类的成员变量

• java.lang.reflect.Constructor:代表类的构造器

2Class类和获取Class实例

在Object类中定义了以下的方法，此方法将被所有子类继承：

public final native Class<?> getClass();

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

2.1Class类概述

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

• Class本身也是一个类

• Class 对象只能由系统建立对象

• 一个加载的类在 JVM 中只会有一个Class实例

• 一个Class对象对应的是一个加载到JVM中的一个.class文件

• 每个类的实例都会记得自己是由哪个 Class 实例所生成

• 通过Class可以完整地得到一个类中的所有被加载的结构

• Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

2.2Class类常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	调用缺省构造函数，返回该Class对象的一个实例
getName()	返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或void ）名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class [] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Class getSuperclass()	返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()	返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个Method对象，此对象的形参类型为paramType

    @Test
    public void test1() throws Exception{
        Class clazz = Person.class;
        //1.通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class,int.class);
        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person) obj;
        System.out.println(p.toString());
        //2.通过反射，调用对象指定的属性、方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p.toString());

        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        System.out.println("*******************************");

        //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
        //调用私有的构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);

        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"GuanYu");
        System.out.println(p1);

        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
        System.out.println(nation);
    }

public class Person {
    private String name;
    public int age;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    private Person(String name) {
        this.name = name;
    }

    public Person() {
        System.out.println("Person()");
    }

    public void show(){
        System.out.println("你好，我是一个人");
    }

    private String showNation(String nation){
        System.out.println("我的祖国是：" + nation);
        return nation;
    }
}

2.3获取Class类的实例(四种方法)

    @Test
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二：通过运行时类的对象,调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);
        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.nie.reflection.java1.Person");
//        clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1 == clazz3);
        //方式四：使用类的加载器：ClassLoader  (不常用)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.nie.reflection.java1.Person");
        System.out.println(clazz4);
        System.out.println(clazz1 == clazz4);
    }

2.4Class实例的常用结构

1）class： 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类

2）interface：接口

3）[]：数组

4）enum：枚举

5）annotation：注解@interface

6）primitive type：基本数据类型

7）void

  @Test
    public void test4(){
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
        // 只要数组的元素类型与维度一样，就是同一个Class
        System.out.println(c10 == c11);
    }

3通过反射获取类的成员

3.1反射获取构造方法

获取类构造器的常用方法

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor<T> getConstructor(Class<?>... parameterTypes)	返回单个公共构造方法对象
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)	返回单个构造方法对象

 代码

   @Test
    //通过反射获取类的构造器信息
    public void test01() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> clazz = Class.forName("com.nie.reflection.java1.Person");
        Constructor<?>[] constructors = clazz.getConstructors();//获取public权限的构造方法
        for (Constructor constructor:constructors) {
            System.out.println(constructor);
        }
        System.out.println("----------------");
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor declaredConstructor:declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        System.out.println("----------------");
        //参数类型 对应的是构造器参数类型，无参构造器，不需要传参
        //Person(String name, int age) 对应getConstructor(String.class,int.class);
        Constructor<?> constructor1 = clazz.getConstructor();
        // Constructor<?> constructor2 = clazz.getConstructor(String.class);//只能访问public权限的
        Constructor<?> constructor2 = clazz.getConstructor(String.class,int.class);
        System.out.println(constructor1);
        System.out.println(constructor2);
        System.out.println("----------------");
        //推荐使用 Declared系列的方法
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(declaredConstructor);
    }

创建对象的方法

方法名	说明
T newInstance(Object...initargs)	根据指定的构造方法创建对象
setAccessible(boolean flag)	设置为true,表示取消访问检查

   @Test
    //创建对象
    public void test02() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<Person> personClass = Person.class;
        Constructor<Person> declaredConstructor = personClass.getDeclaredConstructor();
        //newInstance()调用的是Person的无参构造方法，  无论什么方式只要创建对象只能通过构造器
        Person person = declaredConstructor.newInstance();
        person.setAge(13);
        person.setName("张飞");
        System.out.println(person);
        System.out.println("---------------------");
        Constructor<Person> constructor1 = personClass.getDeclaredConstructor(String.class);//私有化构造器不能创建对象
        constructor1.setAccessible(true);//默认false 设置为true时，可以创建非public的实例
        Person person1 = constructor1.newInstance("刘备");
    }

3.2反射获取成员变量并赋值

获取字段常用方法

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

代码

    //Class类获取成员变量对象
    @Test
    public void test03() throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
        Class<?> clazz = Class.forName("com.nie.reflection.java1.Person");
        // Field[] fields = clazz.getFields(); //获取public的字段
        Field[] fields = clazz.getDeclaredFields(); //获取所有的字段
        for (Field field:fields) {
            System.out.println(field);
        }
        Field name = clazz.getDeclaredField("name");//获取指定名称的成员变量
        System.out.println(name);
    }

Field类用于给成员变量赋值的方法

方法名	说明
void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值

代码

    //Class类获取成员变量对象并赋值
    @Test
    public void test04() throws Exception {
        Class<?> clazz = Class.forName("com.nie.reflection.java1.Person");
        Field nameField = clazz.getDeclaredField("name");//获取指定名称的成员变量
        Field age = clazz.getDeclaredField("age");
        nameField.setAccessible(true);
        System.out.println(nameField);
        Person o = (Person)clazz.newInstance();
        nameField.set(o,"关羽");
        age.set(o,13);
        System.out.println(o);
    }

2.3反射获取成员方法并调用

获取成员方法对象的方法

方法名	说明
Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>... parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes)	返回单个成员方法对象

代码

   @Test
    //获取成员方法对象
    public void test05() throws Exception{
        Class<?> clazz = Class.forName("com.nie.reflection.java1.Person");
        Method[] declaredMethods = clazz.getDeclaredMethods();//只有本类不包含父类
        for (Method declaredMethod:declaredMethods) {
            System.out.println(declaredMethod);
        }
        System.out.println("--------------");
        //getDeclaredMethod(String name, Class<?>... parameterTypes)
        //name 是方法名称  parameterTypes是方法的入参
        Method toString = clazz.getDeclaredMethod("toString");
        System.out.println(toString);
        Method setName = clazz.getDeclaredMethod("setName", String.class);
        System.out.println(setName);
    }

对获取的方法执行

方法介绍

Object invoke(Object obj, Object... args)

• 参数一: 用obj对象调用该方法
• 参数二: 调用方法的传递的参数(如果没有就不写)
• 返回值: 方法的返回值(如果没有就不写)

    @Test
    //获取成员方法对象
    public void test06() throws Exception{
        Class<?> clazz = Class.forName("com.nie.reflection.java1.Person");
        //getDeclaredMethod(String name, Class<?>... parameterTypes)
        //name 是方法名称  parameterTypes是方法的入参
        Method showNationMethod = clazz.getDeclaredMethod("showNation",String.class);
        Method setAgeMethod = clazz.getDeclaredMethod("setAge", int.class);
        Person o = (Person)clazz.newInstance();
        showNationMethod.setAccessible(true);//showNation是private的
        String result1 = (String) showNationMethod.invoke(o, "中国");
        setAgeMethod.invoke(o,12);//赋值年龄12
        System.out.println(o);
    }