java_反射（获取运行时类的完整结构）

最新推荐文章于 2022-06-30 22:23:03 发布
最新推荐文章于 2022-06-30 22:23:03 发布
阅读量226 收藏
点赞数
分类专栏： java_反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46100517/article/details/114847573
版权

了解

一、演示时所需要的类、接口、注解

Person类

package com.company1;

@MyAnnotation(value="hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    public Person(){}

    @MyAnnotation(value="abc")
    private Person(String name){
        this.name = name;
    }

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

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

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


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

    @Override
    public int compareTo(String o) {
        return 0;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

Creature类

package com.company1;

import java.io.Serializable;

public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }

    public void eat(){
        System.out.println("生物吃东西");
    }

}

MyInterface接口

package com.company1;

public interface MyInterface {
    void info();
}

MyAnnotation 注解

package com.company1;

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

import static java.lang.annotation.ElementType.*;


@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

二、演示获取运行时类的完整结构

1、获取当前运行时类的属性结构

package com.company2;

import com.company1.Person;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * 获取当前运行时类的属性结构
 */
public class FieldTest {

    @Test
    public void test1(){

        Class clazz = Person.class;

        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        }
        System.out.println("-------------------");

        //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
    }

    //权限修饰符  数据类型 变量名
    @Test
    public void test2(){
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            //1.权限修饰符
            int modifier = f.getModifiers();
            System.out.print(Modifier.toString(modifier) + "\t");

            //2.数据类型
            Class type = f.getType();
            System.out.print(type.getName() + "\t");

            //3.变量名
            String fName = f.getName();
            System.out.print(fName);

            System.out.println();
        }
    }
}

test1 结果
在这里插入图片描述
test2 结果
在这里插入图片描述

2、获取运行时类的方法结构

package com.company2;


import com.company1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * 获取运行时类的方法结构
 */
public class MethodTest {

    @Test
    public void test1(){

        Class clazz = Person.class;

        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }
        System.out.println("-------------------");
        //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }
    }

    /*
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            //1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for(Annotation a : annos){
                System.out.println(a);
            }

            //2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");

            //3.返回值类型
            System.out.print(m.getReturnType().getName() + "\t");

            //4.方法名
            System.out.print(m.getName());
            System.out.print("(");
            
            //5.形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                for(int i = 0;i < parameterTypes.length;i++){
                    if(i == parameterTypes.length - 1){
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                }
            }
            System.out.print(")");

            //6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length > 0){
                System.out.print("throws ");
                for(int i = 0;i < exceptionTypes.length;i++){
                    if(i == exceptionTypes.length - 1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName() + ",");
                }
            }
            System.out.println();
        }
    }
}

test1 结果
在这里插入图片描述
test2 结果
在这里插入图片描述

3、获取构造器结构、获取运行时类的父类、获取运行时类的带泛型的父类、获取运行时类的带泛型的父类的泛型、获取运行时类实现的接口、获取运行时类所在的包、获取运行时类声明的注解

package com.company2;


import com.company1.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class OtherTest {

    /*
    获取构造器结构
     */
    @Test
    public void test1(){

        Class clazz = Person.class;
        //getConstructors():获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c : constructors){
            System.out.println(c);
        }

        System.out.println();
        //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c);
        }

    }

    /*
    获取运行时类的父类
     */
    @Test
    public void test2(){
        Class clazz = Person.class;

        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

    /*
    获取运行时类的带泛型的父类
     */
    @Test
    public void test3(){
        Class clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    /*
    获取运行时类的带泛型的父类的泛型
    代码：逻辑性代码  vs 功能性代码
     */
    @Test
    public void test4(){
        Class clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
//        System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class)actualTypeArguments[0]).getName());
    }

    /*
    获取运行时类实现的接口
     */
    @Test
    public void test5(){
        Class clazz = Person.class;

        Class[] interfaces = clazz.getInterfaces();
        for(Class c : interfaces){
            System.out.println(c);
        }

        System.out.println();
        //获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c : interfaces1){
            System.out.println(c);
        }

    }
    /*
        获取运行时类所在的包
     */
    @Test
    public void test6(){
        Class clazz = Person.class;

        Package pack = clazz.getPackage();
        System.out.println(pack);
    }

    /*
        获取运行时类声明的注解
     */
    @Test
    public void test7(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annos : annotations){
            System.out.println(annos);
        }
    }

}

test1 结果
在这里插入图片描述
test2 结果
在这里插入图片描述
test3 结果
在这里插入图片描述
test4 结果
在这里插入图片描述
test5 结果
在这里插入图片描述
test6 结果
在这里插入图片描述
test7 结果
在这里插入图片描述

揽月随风醉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反射API
CSDN_SHY的博客
05-26 236
反射 java反射机制就是在运行状态中，对任意一个类，都能够知道这个类的所有属性和方法，对于任意一个 对象，都能够调用它的任一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能叫java 语言的反射机制。 java反射机制主要提供了一下功能 在运行时判断任意一个对象所属的类 在运行时构造任意一个类的对象 在运行时判断任意一个类所具有的成员变量和方法 在运行时调用任意一个对象的方法；生成动态代理 编译和运行：编译时刻加载类是静态加载类、运行时刻加载类是动态加载类 大家都知道，要让Java程序能够运行
Java反射机制 - 相关API
牛八少爷的专栏
01-09 235
目录   1. 反射机制 2.反射常用API 2.1 Class相关API 2.2 Method相关API 2.3 Annotation注解API 2.4 字段相关API 2.5 接口相关API 1. 反射机制 Java反射机制是在运行状态中，对于任意一个实体类，可以知道这个类的所有属性和函数；对于任意一个对象，都能调用它的任意函数和属性； 2.反射常用API 2.1 Cl...
反射有哪些常见的API呢？
qq_25073223的博客
06-30 351
反射常见API简介说明
反射相关API整理
MaPengHao的专栏
11-21 248
概述 很多主流的IOC框架，像移动端的Retrofit、服务端的Spring等的核心思想都是通过反射去实现的，阅读源码的时候有很多反射相关的API调用，而这些东西在平时开发中很少用到，时间久了就会忘记，写下这篇文章来整理复习一下，顺便做个记录。 继承关系 Class类 获取Class对象 class对象包含了这了类的fields、methods、constructors。 Example：World worldObj，获取它的class对象的方式： Class.forName(World..
JAVA反射API以及常见用法
页面无法显示_(:з」∠)__
03-23 499
JAVA反射机制： 利用JAVA已有的API动态操作类文件，完成对类的操作。 相对于静态只能在编译过程中操作类。 运用反射API可以在运行过程中，完成对类的增删改查。 以完成特定的需求。 常见的反射API功能： 一：动态加载一个类 方法：使用Class类的静态方法 static 二：动态加载一个类 三：动态创建对象 四：动态访问属性
浅谈Java自定义注解和运行时靠反射获取注解
09-01
return "java反射获取annotation的测试"; } // ... getters and setters } ``` 最后，我们可以通过反射在运行时获取这些注解信息，例如创建一个帮助类`SortableField`来处理注解字段并根据注解的`order`排序： `...
651.649.JAVA基础教程_反射-获取运行时类的方法结构(651).rar
11-09
总结，Java反射提供了一种强大的能力，让我们可以在运行时动态地获取和操作类的方法结构。通过`Class`对象，我们可以获取到类的详细信息，并通过方法对象进行实际的调用。理解并熟练运用反射机制，能够极大地提高...
java反射之获取类的信息方法(推荐)
08-30
Java 反射机制是 Java 语言中一种非常强大的机制，它可以在运行时检查和修改类的结构。今天，我们将探索如何使用 Java 反射机制来获取类的信息，包括成员函数、成员变量和构造函数信息。 1. 获取成员函数信息 成员...
653.651.JAVA基础教程_反射-获取运行时类的构造器结构(653).rar
11-09
Java反射机制是Java编程...通过以上讲解，你应该对Java反射机制以及如何获取运行时类的构造器结构有了深入的理解。实践是检验理论的最好方式，尝试编写一些示例代码，进一步熟悉这些概念和方法，将有助于巩固你的知识。
650.648.JAVA基础教程_反射-获取运行时类的属性结构及其内部结构(650).rar
11-09
Java反射是Java编程语言中的一个强大特性，它允许程序在运行时检查类、接口、字段和方法...本教程的650.648.JAVA基础教程将详细讲解如何利用反射获取运行时类的属性结构及其内部结构，帮助你更好地理解和运用这一特性。
java 获取程序运行环境的信息
06-21
java 获取程序运行环境的信息 java 获取程序运行环境的信息 java 获取程序运行环境的信息
API之反射
书生
01-20 358
package com.rayNotes; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Array
java 获取调用代码所在的类
daodfs1的博客
01-08 1292
package com.xxx.demo.common.util; public abstract class ClazzUtil { /** * @return 调用方的全限定类名 */ public final String getClazzName() { return getClazz().getName(); } /** * @return 调用方的全限定类 */ public final Class<?> getClazz() { retu
java 反射 Method类API整理
小蓝的博客
05-31 3948
1.继承关系：java.lang.Object L---&gt; java.io.Reader L---&gt; java.io.BufferedReader2所有已实现的接口： AnnotatedElement, GenericDeclaration, Member 3.字段从接口 java.lang.reflect.Member 继承的字段 static final int PUBLI...
java获取启动类的名字
name_z的专栏
03-21 1946
public static String getMainClassName() { StackTraceElement[] stackTraceElements = new RuntimeException().getStackTrace(); for (StackTraceElement stackTraceElement : stackTraceElements) { ...
Java运行时获取当前运行代码类名、方法名
Welcome to ray's blog home page
06-24 2577
/*    * 1.获取当前运行代码的类名，方法名，行号，主要是通过java.lang.StackTraceElement类 *  * 2. 获取调用者、当前方法名 *   [1]获得调用者的方法名, 同new Throwable *         String _methodName = new Exception().getStackTrace()[1].getMethodName(); *...
java field api_Java反射常用的API汇总
weixin_42478330的博客
02-13 252
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。JAVA反射(放射)机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。但是JAVA有...
c#反射整理一：API
qq_24915207的博客
04-25 1050
仅作为个人整理，防止他人博客关闭导致收藏的页面drop掉 反射介绍 http://www.cnblogs.com/guowenhui/archive/2011/12/18/2291552.html 在程序中，当我们需要动态的去加载程序集的时候(将对程序集的引用由编译时推移到运行时)，反射是一种很好的选择。反射为.NET类型提供了高度的动态能力，包括：元数据的动态查询、绑定与执行、动态代码生...
详解Java8中如何通过方法引用获取属性名
热门推荐
Brucelwl的博客
04-26 1万+
在我们开发过程中常常有一个需求，就是要知道实体类中Getter方法对应的属性名称（Field Name），例如实体类属性到数据库字段的映射，我们常常是硬编码指定 属性名，这种硬编码有两个缺点。 1、编码效率低：因为要硬编码写属性名，很可能写错，需要非常小心，时间浪费在了不必要的检查上。 2、容易让开发人员踩坑：例如有一天发现实体类中Field Name定义的不够明确，希望换一个Field Name...
Java 软件开发复习提纲.pdf
最新发布
05-08
6. **反射**：Java反射API允许程序在运行时动态地获取类的信息（如类名、方法名、参数类型）并调用方法，提供强大的元编程能力。 7. **IO流**：Java的IO库提供了处理输入和输出的各种流，如File类、InputStream/...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值