十六、反射

一、反射的作用

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

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

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

• 在运行时获取泛型信息

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

• 在运行时处理注解 生成动态代理

回到顶部

二、反射的api(java.lang.Class)

api:

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

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

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

关于 java.lang.Class的理解

类的加载过程：

　　javac.exe 生成一个或者多个字节码文件（.class）, java.exe 命令对某个字节码文件进行解释运行，相当于某个字节码文件加载到内存中。此过程就称为类的加载。

　　加载到内存中的类，我们就称为运行时类，此运行时类就作为Class的一个实例 ；也就是说：new Person()，这是造对象的一个过程， 那么 Person.class 也是在造对象，他是Class的一个对象；Class的一个实例就对应这一个运行时类；

　　加载到内存中的运行时类，会缓存一定的时间。在此时间内，我们可以通过不同的方式来获取运行时类，Class实例的方式获取方式常用的有3种，下面会讲到；

clazz1,clazz2,clazz3 指向的同一个运行时类的地址;如下代码System.out.println(clazz1 == clazz2);  System.out.println(clazz2 == clazz3);都是true；

 

Class实例的方式获取方式常用的有3种

 

方式一调用运行时类的属性：

　　Class clazz1 = Person.class;

方式二通过运行时类的对象：

　　Person p1 = new Person(); 　　Class clazz2 = p1.getClass();

方式3调用Class的静态方法：forName(String classPath)，最常用的：

　　Class clazz3 = Class.forName("reflect.Person");

其他如使用类的加载器：

　　ClassLoader classLoader = Day6_Conception.class.getClassLoader();

/**
     * 获取Class实例的方式
     * 
     * @Description
     * @author lixiuming
     * @throws ClassNotFoundException
     * @date 2021年9月19日上午10:43:48
     *
     */

    @Test
    public void test3() throws ClassNotFoundException {
        // 方式一：调用运行时类的属性
        // Class clazz1 = Person.class;//这样也可以
        Class<Person> clazz1 = Person.class;
        System.out.println(clazz1);

        // 方式二：通过运行时类的对象
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        // 方式三：调用Class的静态方法：forName(String classPath)，最常用的
        Class clazz3 = Class.forName("reflect.Person");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);

        // 方式四使用类的加载器
        ClassLoader classLoader = Day6_Conception.class.getClassLoader();
        classLoader.loadClass("reflect.Person");

    }

 关于方式四的补充：

    @Test
    public void test5() throws IOException {
        Properties prop = new Properties();
        // 默认文件识别位置在src下
        ClassLoader clazzLoader = Day6_Conception.class.getClassLoader();
        InputStream is = clazzLoader.getResourceAsStream("test.properties");
        prop.load(is);// 加载对应流文件
        String name = prop.getProperty("name");
        String value = prop.getProperty("password");
        System.out.println("name:" + name);
        System.out.println("value:" + value);
    }

 

Properties读取文件的普通方式：

@Test
    public void test5() throws IOException {
        Properties prop = new Properties();
        // 默认此时的文件在当前工程下
        // 读取文件方式一
        FileInputStream fis = new FileInputStream(new File("test.properties"));
        prop.load(fis);// 加载对应流文件
        String name = prop.getProperty("name");
        String value = prop.getProperty("password");
        System.out.println("name:" + name);
        System.out.println("value:" + value);
    }

 

哪些类型可以有Class对象

• 1.class :外部类、成员（成员内部类，静态内部类，局部内部类，匿名内部类）

• 2.interface：接口

• 3.enum:枚举

• 4.[]:数组；

• 5.annotation：注解

• 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
        Class c11 = a.getClass();
        Class c12 = b.getClass();
        System.out.println(c11 == c12);

    }

 

回到顶部

 三、反射动态性的体现

/**
     * 创建一个指定类的对象 classPath：指向一个全类名 当只有在运行时才能确定创建的类需要用到该方法
     * 
     * 体现反射的动态性
     * 
     * @Description
     * @author lixiuming
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws ClassNotFoundException
     * @date 2021年9月19日下午10:58:33
     *
     */
    @Test
    public void test7() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        int a = new Random().nextInt(3);// 0,1,2
        String classPath = "";
        switch (a) {
        case 0:
            classPath = "java.util.Date";
            break;
        case 1:
            classPath = "java.lang.Object";
            break;
        case 2:
            classPath = "reflect.Person";
            break;
        }
        System.out.println(getInstance(classPath));
    }

    /**
     * 创建一个指定类的对象 classPath：指定类的全类名
     * 
     * @Description
     * @author lixiuming
     * @date 2021年9月20日下午10:31:01
     * @param path
     * @return
     * @throws ClassNotFoundException
     * @throws InstantiationException
     * @throws IllegalAccessException
     *
     */
    private Object getInstance(String path)
            throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class clazzClass = Class.forName(path);
        Object obj = clazzClass.newInstance();
        return obj;
    }

 

回到顶部

四、使用反射/不使用反射对类的操作的对比

结论：

使用反射可以获取对象私有个属性、方法、构造器，而没有使用反射的话，不能获取对象的私有的属性、方法、构造器；

对比代码如下：

// 反射之前，对于Person的操作
    @Test
    public void test1() {
//1.创建Person类的对象
        Person p1 = new Person("tom", 12);
        // 2.调用内部的属性和方法
        p1.age = 10;
        System.out.println(p1.toString());
        p1.show();
        // 在Person类外部，不可以调用Person类的私有结构
        // 比如，私用的name showNation以及私用构造器；

    }

    // 反射之后，对于Person的操作:调用私有结构。比如私有构造器、方法和属性；
    //
    @Test
    public void test2() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
        // 通过反射，创建Person类的对象
        Class clazz = Person.class;
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object object = constructor.newInstance("tome", 12);
        System.out.println(object.toString());

Person类

package reflect;

public class Person {
    private String name;
    public int 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) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

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

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

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

}

问题点

疑问1 通过直接new 对象的方式或者反射的方式都可以调用公共的结构，开发中到底用哪个？
建议：直接new的方式
疑问2： 什么时候会用反射的方式；

编译时候的确定不下来传哪个对象，
疑问3，反射机制与面向对象中的封装性是不是矛盾的，如何看待两个技术？
 不矛盾。封装性：建议不要调用私有(属性，方法，构造器)；反射：能不能调用私有(属性，方法，构造器)

 

回到顶部

五、通过反射，获取类中的结构：

1.获取属性

• clazzClass.getFields()// 获取当前运行时类及其父类的public访问权限的属性

• clazzClass.getDeclaredFields();// 获取当前运行时类中声明的所有属性，不包括父类

@Test
    public void test8xx() {
        Class clazzClass = Man.class;

        // 获取属性*********************************************************************
        System.out.println("***********获取当前运行时类及其父类的public访问权限的属性**********");
        Field[] fields = clazzClass.getFields();// 获取当前运行时类及其父类的public访问权限的属性,public double reflect.Creater.weight
        for (Field item : fields) {
            System.out.println(item);// public int reflect.Man.id
        }
        System.out.println("****************获取当前运行时类中声明的所有属性，不包括父类***************************");
        Field[] fields1 = clazzClass.getDeclaredFields();// 获取当前运行时类中声明的所有属性，不包括父类，
        for (Field item : fields1) {
            System.out.println(item);

            // 1.获取权限修饰符
            int a = item.getModifiers();
            System.out.println("属性权限修饰符：" + Modifier.toString(a));
            // 2.数据类型
            System.out.println("属性的数据类型（带class）：" + item.getType());
            System.out.println("属性的数据类型（不带class）：" + item.getType().getName());
            // 3.变量名
            System.out.println("属性的名称：" + item.getName());
        }

2.获取方法

@Test
    public void test8xx() {
        Class clazzClass = Man.class;

        // 获取方法*********************************************************************
        System.out.println("**************获取当前运行时类及其父类的public访问权限的*********************");
        Method[] methods = clazzClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("*************************获取当前运行时类中声明的所有方法，不包括父类************************************");
        // 1.获取注解
        Method[] methods1 = clazzClass.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
            Annotation[] annotations = method.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println("获取注解：" + annotation);
                System.out.println("获取注解类型：" + annotation.annotationType());
            }
            // 2.方法权限修饰符
            int a = method.getModifiers();
            System.out.println("方法权限修饰符：" + Modifier.toString(a));
            // 3.获取返回值类型
            System.out.println("方法返回值类型：" + method.getReturnType());
            // 4.获取方法名称
            System.out.println("方法名称：" + method.getName());
            // 5.形参列表
            Class[] parameterTypes = method.getParameterTypes();
            for (int i = 0; i < parameterTypes.length; i++) {
                System.out.println("    第" + (i + 1) + "个参数名称：" + parameterTypes[i].getName());

            }
            // 6.获取抛出异常
            Class[] exceptionTypes = method.getExceptionTypes();
            for (int i = 0; i < exceptionTypes.length; i++) {
                System.out.println("    第" + (i + 1) + "个异常名称：" + exceptionTypes[i].getName());

            }
        }
    }

3.获取类

@Test
    public void test8xx() {
        Class clazzClass = Man.class;

        System.out.println("***************************获取当前运行时类中声明的所有构造器，不包括父类***************************");
        Constructor[] constructors2 = clazzClass.getDeclaredConstructors();
        for (Constructor cons : constructors2) {
            System.out.println(cons);
        }

        System.out.println("************************获取当前运行时类的父类 & 带泛型的父类 & 带泛型的父类的泛型***********************");
        Class superclass = clazzClass.getSuperclass();
        System.out.println("获取当前运行时类的父类:" + superclass.getName());
        System.out.println(superclass.getSimpleName());
        Type genericSuperclass = clazzClass.getGenericSuperclass();
        System.out.println("带泛型的父类:" + genericSuperclass);
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        for (int i = 0; i < actualTypeArguments.length; i++) {
            Class temp = (Class) actualTypeArguments[i];
            System.out.println("    带泛型的父类的泛型:" + actualTypeArguments[i].getTypeName());
            System.out.println("    带泛型的父类的泛型:" + temp.getSimpleName());
        }

        System.out.println("*********************************获取当前运行时类的接口************************************");
        Class[] interfaces = clazzClass.getInterfaces();
        for (Class cls : interfaces) {
            System.out.println(cls.getName());
            System.out.println(cls.getSimpleName());
        }
//获取运行时类的父类的接口
        Class[] interfaces2 = clazzClass.getSuperclass().getInterfaces();
        for (Class cls : interfaces2) {
            System.out.println(cls.getName());
            System.out.println(cls.getSimpleName());
        }
    }

4.获取包：

@Test
    public void test8xx() {
        Class clazzClass = Man.class;

        System.out.println("*********************************获取当前运行时所在的包************************************");
        Package package1 = clazzClass.getPackage();
        System.out.println(package1.getName());
        System.out.println("*********************************获取当前运行时类声明的注解************************************");
        Annotation[] annotations2 = clazzClass.getAnnotations();
        for (Annotation item : annotations2) {
            System.out.println(item);
        }
    }

回到顶部

六、调用运行时类中指定的接口：属性、方法、构造器

1.调用属性

步骤：

1.获取指定的属性　　　　Field fiedName = clazzClass.getDeclaredField("name");//name是属性名称

2.保证可访问：fiedName.setAccessible(true)

3.获取、设置指定对象的此属性的值；fiedName.set(man, "Tom");//man是对象，"Tom"是参数;(String) fiedName.get(man);//获取设置好对象属性

@Test
    public void test8xx()
            throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
        Class clazzClass = Man.class;

        Man man = (Man) clazzClass.newInstance();
        // 获取指定的属性
        Field field = clazzClass.getField("id");
        // 设置当前属性值
        field.setInt(man, 1001);

        // 获取当前属性的值
        int mId = (int) field.get(man);
        System.out.println(mId);

        // 获取指定的属性
        Field fiedAge = clazzClass.getDeclaredField("age");
        // 设置当前属性值
        fiedAge.setInt(man, 1001);

        // 获取当前属性的值
        int mAge = (int) fiedAge.get(man);
        System.out.println(mAge);

        // 1.获取指定的属性
        Field fiedName = clazzClass.getDeclaredField("name");

        // 2.保证当前属性可访问
        fiedName.setAccessible(true);// 否则不打印Tom
        // 3.获取、设置指定对象的此属性的值；
        fiedName.set(man, "Tom");

        // 获取当前属性的值
        String name = (String) fiedName.get(man);
        System.out.println(name);
    }

2.调用指定方法

• 获取非静态方法步骤：

　　1.获取指定的方法：Method declaredMethod = clazzClass.getDeclaredMethod("show", java.lang.String.class);

　　2.保证可访问：declaredMethod2.setAccessible(true);

　　3.调用方法，并且加入参数：Object returnValue = declaredMethod.invoke(man, "USA")

　　补充：invoke()的返回值即为对应类中调用的方法的返回值

• 获取静态方法步骤：

　　1.获取指定的方法：Method declaredMethod2 = clazzClass.getDeclaredMethod("shwoDesc");//shwoDesc为方法名

　　2.保证可访问：declaredMethod2.setAccessible(true);

　　3.调用方法：Object returnValue2 = declaredMethod2.invoke(Man.class);

　　补充：若果调用的运行时类中的方法没有返回值，则此invoke返回nul

 

@Test
    public void test8xx() throws InstantiationException, IllegalAccessException, NoSuchMethodException,
            SecurityException, IllegalArgumentException, InvocationTargetException {
        Class clazzClass = Man.class;
        Man man = (Man) clazzClass.newInstance();
        // 获取指定的方法
        // 1.获取指定的方法
        Method declaredMethod = clazzClass.getDeclaredMethod("show", java.lang.String.class);

        // 2.保证当方法性可访问
        declaredMethod.setAccessible(true);// 否则不打印Tom
        // 3.调用方法并且加入参数；
        Object returnValue = declaredMethod.invoke(man, "USA");// invoke()的返回值即为对应类中调用的方法的返回值

        
        System.out.println(returnValue);

        // 获取指定的方法(静态)
        // 1.获取指定的方法
        Method declaredMethod2 = clazzClass.getDeclaredMethod("shwoDesc");

        // 2.保证当方法性可访问
        declaredMethod2.setAccessible(true);// 否则不打印Tom
        // 3.调用方法；
        Object returnValue2 = declaredMethod2.invoke(Man.class);// 若果调用的运行时类中的方法没有返回值，则此invoke返回null

        System.out.println(returnValue2);
    }

3.调用知道构造器

1.获取指定构造器并指明构造器的参数列表：clazzClass.getDeclaredConstructor(String.class)

2.保证可访问：declaredConstructor.setAccessible(true);

3.创建运行时类的对象：eclaredConstructor.newInstance("JERRY");

    @Test
    public void test8xx() throws NoSuchMethodException, SecurityException, InstantiationException,
            IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Class clazzClass = Man.class;
        // 获取指定构造器
        Constructor declaredConstructor = clazzClass.getDeclaredConstructor(String.class);// 指明构造器的参数列表
        declaredConstructor.setAccessible(true);
        // 创建运行时类的对象
        Object newInstance = declaredConstructor.newInstance("JERRY");
        System.out.println(newInstance);
    }

回到顶部

补充：

创建对象的方式：

• new+构造器
• 要创建Xxx类的对象，可以考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中是否有静态方法存在，可以调用静态方法创建Xxx对象；
• 通过反射实现；

回到顶部

附录：

Man:

package reflect;

@MyAnnotation
public class Man extends Creater<String> implements Comparable<String>, MyInfo {

    @Override
    public int compareTo(String o) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void info() {
        // TODO Auto-generated method stub

    }

    private String name;
    int age;
    public int id;

    public Man() {

    }

    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 int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

    @MyAnnotation(value = "hi")
    public Man(String name) {
        super();
        this.name = name;
    }

    private Man(int age) {
        super();
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation) {
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

    public String display(String interests, int age) throws java.lang.NullPointerException {
        return interests + age;
    }

    private static void shwoDesc() {
        System.out.println("我是一个可爱的人");
    }

    @Override
    public String toString() {
        return "Man [name=" + name + ", age=" + age + ", id=" + id + "]";
    }

}

MyAnnotation

package reflect;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE })
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

    String value() default "hello";
}

MyInfo

package reflect;

public interface MyInfo {

    void info();

}