反射一目了然

反射

拿出去跑一下知道都是干啥的了

        Class<User> userClass = User.class;
        //获取运行时public修饰的构造
        Constructor<?>[] constructors = userClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            //System.out.println(constructor);
        }

        //无参构造
        Constructor<User> constructor1 = userClass.getConstructor();
        //带参构造
        Constructor Constructor = userClass.getConstructor(Integer.class, String.class, String.class, String.class, Integer.class, Integer.class);
        //System.out.println(Constructor);

        //获取运行时全部类型（private...等）的构造
        Constructor<?>[] declaredConstructors = userClass.getDeclaredConstructors();
        for (Constructor<?> constructor : declaredConstructors) {
            //System.out.println(constructor);
        }
        //获取所有修饰服的构造 无参、多参
        Constructor declaredConstructor = userClass.getDeclaredConstructor(Integer.class);
        //System.out.println(declaredConstructor);

        //-------------------------------------------------------------构造器⬆️
        //-----------------------------------------------------------创建对象⬇️

        Object o = Constructor.newInstance(1, "1", "1", "1", 2, 2);
        //System.out.println(o);


        //-----------------------------------------------------------属性⬇️

        //获取 父类子类中所有 public 修饰的属性
        Field[] fields = userClass.getFields();
        for (Field f : fields) {
            //    System.out.println(f);
        }
        //获取类运行时的所有属性
        Field[] declaredFields = userClass.getDeclaredFields();
        for (Field f : declaredFields) {
            //    System.out.println(f);
        }
        //获取单个属性public修饰的 包括当前类还有“父类”
        Field base = userClass.getField("base");
        //System.out.println(base); //public java.lang.String com.boge.pojo.UserBase.base
        //获取所有当前类中的所有修饰符属性 获取不到父类属性
        Field dId = userClass.getDeclaredField("dId");
        //System.out.println(dId); // private java.lang.Integer com.boge.pojo.User.dId

        //-----------------------------------------------------------获取具体结构⬇️

        //获取当前属性 名称
        String name = dId.getName();
        //System.out.println(name);  //dId

        //获取当前属性对应的 类型
        Class<?> type = dId.getType();
        //System.out.println(type); //class java.lang.Integer

        //获取当前属性的修饰符 modifiers 输出的数字 对应 Modifier 类里面的 修饰符
        int modifiers = dId.getModifiers();
        //System.out.println(modifiers); //2
        //System.out.println(Modifier.toString(modifiers)); //private

        //给属性赋值
        //获取 user 类的 id 属性
        Field id = userClass.getField("id");
        //获取当前实例
        User user = User.class.newInstance();
        //给user对象 id 属性赋值
        id.set(user, 18);
        //输出 User(id=18, userName=null, password=null, realName=null, age=null, dId=null)
        //System.out.println(user);


        //-----------------------------------------------------------获取方法⬇️
        //获取到字节码信息
        Class<? extends User> uClass = user.getClass();

        //获取所有public修饰的方法、父类public的方法
        Method[] methods = uClass.getMethods();
        for (Method method : methods) {
            //System.out.println("methods获取子类父类的所有public方法:"+method);
        }

        //获取当前类的所有public修饰的方法
        Method methodUser = uClass.getMethod("userPay");
        //System.out.println(methodUser); //public void com.boge.pojo.User.userPay()
        //重载
        Method methodUser1 = uClass.getMethod("userPay", Integer.class);
        //重写父类的方法
        Method methodUserBybaseUser = uClass.getMethod("baseUser");
        //System.out.println(methodUser1); //public void com.boge.pojo.User.userPay(java.lang.Integer)

        //获取本类的所有方法 获取不到父类
        Method[] declaredMethods = uClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            //System.out.println("declaredMethods获取运行时类的所有方法:" + declaredMethod);
        }
        //获取本类所有方法获取不到父类
        Method baseUser = uClass.getDeclaredMethod("userPay");
        //System.out.println(baseUser);

        //获取当前方法的名字
        String userName = methodUser.getName();
        System.out.println("方法的名称："+userName);
        //获取修饰符
        System.out.println("当前方法的修饰符："+Modifier.toString(methodUser.getModifiers()));
        //返回值
        System.out.println("返回值："+methodUser.getReturnType());
        //参数列表
        Class<?>[] parameterTypes = methodUser1.getParameterTypes();
        for (Class<?> parameterType : parameterTypes) {
            System.out.println("参数列表："+parameterType);
        }
        System.out.println("参数列表的个数："+methodUser1.getParameterCount());
        Annotation[] annotations = methodUserBybaseUser.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("方法上的注解(只能获取到运行时的注解)："+annotation);
        }

        Class<?>[] exceptionTypes = methodUserBybaseUser.getExceptionTypes();
        for (Class<?> exceptionType : exceptionTypes) {
            System.out.println("异常类型："+exceptionType);
        }

        //调用方法
        User user1 = uClass.newInstance();
        //user1调用对象重写的父类方法  无返回值
        methodUserBybaseUser.invoke(user1);
        //1.先获取user 类的方法
        Method tu = uClass.getMethod("tu", Integer.class);
        //2.创建对象 复用 user1
        System.out.println("调用tu方法->返回值为："+tu.invoke(user1, 1));

        //获取所在类的接口
        Class<?>[] interfaces = userClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("当前类实现的接口："+anInterface);
        }
        //获取到父类的字节码信息
        Class<? super User> superclass = userClass.getSuperclass();
        //父类实现的接口
        Class<?>[] interfaces1 = superclass.getInterfaces();
        for (Class<?> aClass : interfaces1) {
            System.out.println("父类类实现的接口："+aClass);
        }
        //获取当前类的所在包路径
        Package aPackage = userClass.getPackage();
        //包名
        System.out.println(aPackage.getName());
        //路径
        System.out.println(aPackage);