Java-反射

反射：在运行状态的时候，通过类知道又是什么字段和方法，然后可以通过对象调用方法和字段，这种可以动态获取信息和动态的调用对象方法的功能称之为反射机制。

对于反射中常用的类：

1.class类：该类中的方法主要是获取关于构造函数类，字段类，放法类。

一 构造方法

    1-1  getConstructors() 返回包含某个constructor的数组，访问权限为public的所有构造函数。

    1-2 getConstructor(Class<T>··· parameterTypes) 包含某个constructor对象，代表class对象所表示的类的所有公共构造函数

     1-3 getDeclaredConstructors() 返回包含某个constructor的数组，访问所有构造函数。

     1-4 getDeclaredConstructor(Class<T>··· parameterTypes)包含某个constructor对象，代表class对象所表示的类或接口的指定构造函数

二 方法: 与上述的构造方法类似。

    1-5  getMethods()

    1-6 getMethod(String name,Class<T>··· parameterTypes)

    1-7 getDeclaredMethods()

    1-8 getDeclaredMethods(String name,Class<T>··· parameterTypes)

三 字段: 与上述的构造方法类似。

    1-9 getFields()

    1-10 getField(String name)

    1-11 getDeclaredFields()

    1-12 getDeclaredField(String name)

2.Constructor类： 主要提供类的构造方法和获取它的访问权限。

      1. isVarArgs() 查看该构造函数是否允许带有可变数量的参数。

      2. getParameterTypes()获取构造方法的各个参数的类型。

       3. getExceptionTypes()获取构造方法的抛出的异常类型。

       4. newInstance()创建一个无参的对象

3.Field类： 主要提供类或者接口的字段的信息和获取它的访问权限。 

        1. getName()获取该成员变量的名称。

        2. getType()获取成员变量的类型。

        3. get(object obj)获取obj对象的变量值，返回为int类型

        4.set(Object obj，object value)设置obj对象的值，设为value

        5. getInt(object obj)

        6. setInt(obejct obj,int i)

        7 还有getFloat(object obj),setFloat(obejct obj,Float f),getBoolean(object obj),set(object obj,boolean b)。

        8 setAccessible(boolean b)可忽略权限限制可以访问private等私有权限的成员变量。

4.Method类： 主要提供类或者接口中的方法的信息。

        1. getName() 获取该方法的名称。

        2. getParameterTypes()获取该方法的各个参数的类型。

        3. getReturnTypes()获取方法的返回值的类型。

        4. getExceptionTypes()获取方法的抛出的异常类型。

        5 isVarargs()查看该构造函数是否允许带有可变数量的参数，运行返回true,否者返回false

package com.example.demo.reflect;

import com.example.demo.entity.Users;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author hanqiang
 * @Classname ReflectTest
 * @Date 2021/5/15 14:30
 * @Description: 反射类的测试
 */
@SpringBootTest
public class ReflectTest {
    @Test
    void context(){
        try {
            Class<?> c=Class.forName("com.example.demo.entity.Users");
            //变成某个类
            Constructor constructor=c.getConstructor();
            //通过无参函数构造对象
            Users user=(Users)constructor.newInstance();
            //这个方法就属于Constructor
            constructor.getModifiers();

            //获取该类中的可访问的public字段
            Field[] field=c.getFields();
            //获取该类中的可访问的所有字段
            Field[] fields=c.getDeclaredFields();
            for(Field field1:fields){
                System.out.println("输出字段的名称"+field1.getName());
                System.out.println("输出字段的类型"+field1.getType());
            }

            for(Field field1:fields){
                System.out.println("字段为"+field1);
            }
            Stream<Field> sf=Arrays.stream(fields);

            //要注意终止操作符
            // sf.map(s->s.getName()).forEach(System.out::println);
            System.out.println("--------------------------------");
            System.out.println("字段类型输出");
            List<Object> s=sf.map(st-> st.getType().toString()).collect(Collectors.toList());
            s.forEach(System.out::println);
            //List<Object> sto=sf.map(st-> st.getType()).collect(Collectors.toList());
            //System.out.println("数据输出"+sto.toString());



            //获取可以访问的public的方法
            Method[] method=c.getMethods();
            //获取该类中的可访问的所有方法
            Method[] methods=c.getDeclaredMethods();
            System.out.println("方法输出");
            Stream me=Arrays.stream(methods);
            me.forEach(System.out::println);
            System.out.println("-------------------------------");
            for(Method m:methods){
                System.out.println("方法的名称为："+m.getName());
                System.out.println("方法的返回的类型为："+m.getReturnType());
                System.out.println("方法是否又可变数量的参数："+m.isVarArgs());
                System.out.println("方法："+m.getModifiers());
            }


        }catch(Exception e){
            e.printStackTrace();
        }

    }
}