注解与反射

最新推荐文章于 2024-08-17 12:55:31 发布
最新推荐文章于 2024-08-17 12:55:31 发布
阅读量155 收藏 1
点赞数
分类专栏： 自我提升 文章标签： 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renxiaoxu_renxu/article/details/108025703
版权

注解与反射

1、注解

1.1注解的概念

img

注解：能给人看，也能给机器看 ，机器会用反射机制进行访问。

如@Override都是注解，注解具有检查和约束的作用.如把S小写，override就报错了。

img

1.2内置注解

img


package annotation;
import java.util.ArrayList;
import java.util.List;
/**
 * author liulei
 * data  5.21
 * since 1.8
 * version 1.0
 * Description  内置注解演示
 */
public class Demo01 {
    //Override  重写的注释
    @Override
    public String toString(){
        return super.toString();
    }
    //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static void test()
    {
        System.out.println("这是个不被推荐的方法");
    }
    @SuppressWarnings("all")
    public void test02()
    {
        List list = new ArrayList();
    }
    public static void main(String[] args) {
        test();
    }
}

1.3元注解

img

package annotation;
 
import java.lang.annotation.*;
 
/**
 * author liulei
 * data  5.21
 * since 1.8
 * version 1.0
 * Description  元注解演示
 */
@Myannotation
public class Demo02 {
    @Myannotation
    public void test()
    {
    }
    @Myannotation2(age = 18,name = "liulei")
    public void test1(){
    }
    @Myannotation3(value = "ll")
    public void test2(){
    }
 
}
//定义一个注解
//Target 表示注解可以用在哪些地方
//Retention 表示我们的注解在什么地方还有效，作用的范围
//runtime>class>source
//Documented 表示是否将注解生成在Javadoc中
//Inherited  子类可以继承父类的注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface Myannotation{
}
@interface Myannotation2{
    //注解的参数：参数类型+参数名();
    String name() default "";
    int age();
    int id() default -1;//如果默认为-1，代表不存在
    String[] schools() default {"西部开源","清华大学"};
}
@interface Myannotation3{
    String value();//如果只有一个参数，则参数为value
}

2、反射

2.1反射介绍

img

img

img

img

2.2 Class类

img

img

img

img

package Reflection;

/**
 * author liulei
 * data 5.21
 * since 1.8
 * version 1.0
 * Description  获取类对象的Class对象的几种方法
 */
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p = new Student("abc");
        System.out.println("这个人是:"+p.name);
        //方式一：通过对象获得
        Class c1 = p.getClass();
        System.out.println(c1.hashCode());
        //方式二：forname获得
        Class c2 = Class.forName("Reflection.Student");
        System.out.println(c2.hashCode());
        //方式三：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //方式四：基本内置类型都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }

}
class Person{
    public String name;

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

}
class Student extends Person
{
    public Student(String name) {
        this.name = name;
    }
}
class Teacher extends Person
{
    public Teacher() {
    }

    public Teacher(String name) {
        this.name = "老师";
    }
}

img

package Reflection;

import java.lang.annotation.ElementType;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description
 */
public class Test02 {
    public static void main(String[] args) {
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//数组
        Class c4 = int[][].class;//二维数组
        Class c5 = Override.class;//注解
        Class c6 = ElementType.class;//枚举
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9 = Class.class;//Class
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一致，就是同一个Class
        int[] a = new int[10];
        int[] b =new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }
}

2.3类的加载

img

img

img
在这里插入图片描述

package Reflection;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description
 */
public class Test03 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }
}
/*
1 加载到内存，会产生一个类对应的Class对象
2 链接，链接结束后 m = 0
3 初始化
    <clinit>()
    {
       System.out.println("A类静态代码块初始化");
        m = 300;
        m = 100;
    }
 */
class A{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

3、类的初始化

img

package Reflection;

import java.sql.Struct;

/**
 * author liulei
 * data  5.22
 * since 1.8
 * version 1.0
 * Description   类的初始化
 */
public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1主动引用
        Son s = new Son();//new 一个实例
        Class.forName("Reflection.Son");//反射会主动引用
        //2 不会产生引用
        System.out.println(Son.b);//子类引用父类的方法
        Son[] s1 = new Son[5];//通过数组定义类引用
    }
}
class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
    }
    static int m = 100;
    static final int n = 1;
}

4、类的加载作用

img

img

package Reflection;

/**
 * author liulei
 * data  5.22
 * since 1.8
 * version 1.0
 * Description  三种类加载器
 */
public class Test5 {

    //双亲委派机制：java.lang.String-->,多重检测，当自己写的类和跟类(rt.jar)相同时，自己写的类无效
    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();//系统类加载器
        System.out.println(systemClassLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
        ClassLoader parent = systemClassLoader.getParent();//扩展类加载器（是系统类加器的子集或父亲）
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@1b6d3586
        ClassLoader parent1 = parent.getParent();//跟加载器（扩展类加载器的子集或父亲）
        System.out.println(parent1);//null,因为不可访问所以为null
        //测试当前类是那个加载器加载的
        ClassLoader classLoader = Class.forName("Reflection.Test5").getClassLoader();//sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(classLoader);
        //获取jdk内置的类是谁加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);//null
        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        /*
        D:\Eclipse\JDK\jre\lib\charsets.jar;
        D:\Eclipse\JDK\jre\lib\deploy.jar;
        D:\Eclipse\JDK\jre\lib\ext\access-bridge-64.jar;
        D:\Eclipse\JDK\jre\lib\ext\cldrdata.jar;
        D:\Eclipse\JDK\jre\lib\ext\dnsns.jar;
        D:\Eclipse\JDK\jre\lib\ext\jaccess.jar;
        D:\Eclipse\JDK\jre\lib\ext\jfxrt.jar;
        D:\Eclipse\JDK\jre\lib\ext\localedata.jar;
        D:\Eclipse\JDK\jre\lib\ext\nashorn.jar;
        D:\Eclipse\JDK\jre\lib\ext\sunec.jar;
        D:\Eclipse\JDK\jre\lib\ext\sunjce_provider.jar;
        D:\Eclipse\JDK\jre\lib\ext\sunmscapi.jar;
        D:\Eclipse\JDK\jre\lib\ext\sunpkcs11.jar;
        D:\Eclipse\JDK\jre\lib\ext\zipfs.jar;
        D:\Eclipse\JDK\jre\lib\javaws.jar;
        D:\Eclipse\JDK\jre\lib\jce.jar;
        D:\Eclipse\JDK\jre\lib\jfr.jar;
        D:\Eclipse\JDK\jre\lib\jfxswt.jar;
        D:\Eclipse\JDK\jre\lib\jsse.jar;
        D:\Eclipse\JDK\jre\lib\management-agent.jar;
        D:\Eclipse\JDK\jre\lib\plugin.jar;
        D:\Eclipse\JDK\jre\lib\resources.jar;
        D:\Eclipse\JDK\jre\lib\rt.jar;  //java核心库
        D:\Code\IDEA\Stage01\Demo03\out\production\Demo03;//自己的目录
        D:\IDEA\IntelliJ IDEA Community Edition 2020.1.1\lib\idea_rt.jar

         */
    }
}

5、如何获取类的完整结构

img

package Reflection;

import javax.naming.Name;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description  获取运行时类的完整结构
 */
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class aClass = Class.forName("Reflection.user");
        System.out.println(aClass.getName());//报名+类名
        System.out.println(aClass.getSimpleName());//类名
        Field[] fields = aClass.getFields();//获取public的字段
        System.out.println("===================================字段");
        Field[] declaredFields = aClass.getDeclaredFields();//可以获取私有字段
        for(Field field:fields){
            System.out.println(field);//无输出
        }
        for (Field field1:declaredFields){
            System.out.println(field1);//有输出
            /*
            java.lang.String Reflection.user.name
int         Reflection.user.id
int         Reflection.user.age
             */
        }
        //获得指定属性的值
        Field name = aClass.getDeclaredField("name");
        //获取方法
        System.out.println("===============================方法");
        Method[] declaredMethods = aClass.getMethods();//获取本类和父类的所有方法
        for(Method m:declaredMethods){
            System.out.println(m);
        }
        Method[] declaredMethods1 = aClass.getDeclaredMethods();//获取本类的所有方法
        for(Method m1:declaredMethods1){
            System.out.println(m1);
        }
        //获取指定属性的方法
        Method getName = aClass.getDeclaredMethod("getName", null);
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);
        //获取构造器
        System.out.println("=======================================构造器");
        Constructor[] constructors = aClass.getConstructors();
        for (Constructor c:constructors){
            System.out.println(c);
        }
        Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定"+declaredConstructor);
    }

}
class user{
   private String name;
   private int id;
   private int age;

    public user(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    public user() {
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

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

6、利用Class对象创建类的对象属性，方法，泛型，注解等

img

img

img

img

package Reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * author liulei
 * data  5.22
 * since 1.8
 * version 1.0
 * Description  用Class创建对象操作类方法和属性
 */
public class Test7 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> aClass = Class.forName("Reflection.user");
        user instance =(user)aClass.newInstance();//本质是调用不参构造器创建对象
        System.out.println(instance);
        //通过构造器创建对象
        Constructor constructor = aClass.getDeclaredConstructor(String.class,int.class,int.class);
        user haha = (user)constructor.newInstance("haha", 12, 12);
        System.out.println(haha);
        //通过对象获取一个方法
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        setName.invoke(instance,"我的名字");//激活该方法
        System.out.println(instance.getName());
        //获取对象一个属性
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);//不能直接操作私有属性，需要改代码设置关闭安全监测
        name.set(instance,"我的名字");
        System.out.println(instance.getName());


    }
}

使用反射是低效率的，

package Reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


/**
 * author liulei
 * data  5.22
 * since 1.8
 * version 1.0
 * Description  效率分析
 */
public class Test8 {
    //普通方法调用
   public static void  demo01(){
       user u = new user();
       long startTime = System.currentTimeMillis();
       for (int i = 0; i <= 100000000; i++){
           u.getName();
       }
       long endtime = System.currentTimeMillis();
       System.out.println(endtime-startTime);
   }
   //反射方法调用
    public static void  demo02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        user u = new user();
        Class aClass = Class.forName("Reflection.user");
        Method getName = aClass.getDeclaredMethod("getName");
        long startTime = System.currentTimeMillis();
        for (int i = 0; i <= 100000000; i++){
            getName.invoke(u,null);
        }
        long endtime = System.currentTimeMillis();
        System.out.println(endtime-startTime);
    }
    //反射方法调用,关闭监测
    public static void  demo03() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        user u = new user();
        Class aClass = Class.forName("Reflection.user");
        Method getName = aClass.getDeclaredMethod("getName");
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i <= 100000000; i++){
            getName.invoke(u,null);
        }
        long endtime = System.currentTimeMillis();
        System.out.println(endtime-startTime);

    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        demo01();//3
        demo02();//286
        demo03();//155
        //所以反射应用耗时较长，尽量不适用不必要的反射，同时需要关闭监测时尽量关闭监测可以加快时间
    }

}

通过反射获取操作泛型

package Reflection;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description 通过反射获取泛型
 */
public class Test9 {
    public void test01(Map<String,user> map, List<user> list){
        System.out.println("test01");
    }
    public Map<String,user> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method test01 = Test9.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterType = test01.getGenericParameterTypes();
        for(Type gpt:genericParameterType){
            System.out.println("gpt"+gpt);
            if(gpt instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) gpt).getActualTypeArguments();
                for (Type p:actualTypeArguments){
                    System.out.println(actualTypeArguments);
                }
            }
        }
        Method test02 = Test9.class.getMethod("test02", null);
        Type genericParameterTypess = test02.getGenericReturnType();
        if(genericParameterTypess instanceof  ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericParameterTypess).getActualTypeArguments();
            for (Type act:actualTypeArguments){
                System.out.println(actualTypeArguments);
            }
        }
    }
}

img

package Reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

/**
 * author liulei
 * data  5.22
 * since 1.8
 * version 1.0
 * Description  反射获取注解
 */
public class Test10 {
    public static void main(String[] args) throws Exception {
        Class aClass = Class.forName("Reflection.student2");
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation a:annotations){
            System.out.println(a);//属性是私有的，所以没有输出属性的注解
        }
        //获得注解的value的值
        table t = (table) aClass.getAnnotation(table.class);
        String value = t.value();
        System.out.println(value);
        //获得类指定的注解
        Field name = aClass.getDeclaredField("name");
        zidingyi annotation = name.getAnnotation(zidingyi.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@table("db_student")
class student2{
    @zidingyi(columnName = "db_id",type = "int",length = 10)
    private int id;
    @zidingyi(columnName = "db_id",type = "int",length = 10)
    private int age;
    @zidingyi(columnName = "db_id",type = "int",length = 10)
    private String name;

    public student2() {
    }

    public student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface zidingyi{
    String columnName();
    String type();
    int length();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface table{
    String value();
}

Class.getAnnotations() 获取所有的注解，包括自己声明的以及继承的
Class.getAnnotation(Class< A > annotationClass) 获取指定的注解，该注解可以是自己声明的，也可以是继承的
Id() {
return id;
}

public int getAge() {
    return age;
}

public String getName() {
    return name;
}

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

}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface zidingyi{
String columnName();
String type();
int length();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface table{
String value();
}


>  Class.getAnnotations() 获取所有的注解，包括自己声明的以及继承的
> Class.getAnnotation(Class< A > annotationClass) 获取指定的注解，该注解可以是自己声明的，也可以是继承的
> Class.getDeclaredAnnotations() 获取自己声明的注解
night suns
关注
专栏目录
Java注解与反射原理说明
08-26
当注解与反射结合时，我们可以利用反射机制来读取和处理注解中的信息。在Java中，`AnnotatedElement`接口提供了获取注解的方法，包括`getAnnotations()`和`getAnnotation(Class<T> annotationClass)`。 1. `...
反射与注解（详细）
qq_43377329的博客
03-26 2823
文章目录一、注解Annotation1、什么是注解2、内置注解3、元注解4、自定义注解二、反射机制**1、静态vs动态语言**动态语言静态语言2、java反射机制概述3、java反射机制研究及应用**反射机制提供的功能**优点缺点反射相关主要APIclass类class的常用方法获取class类的实例哪些类型有class对象?4、java内存分析static关键字类的加载过程类的加载和ClassLoader的理解什么时候会发生类的初始化？类加载器的作用双亲委派机制ClassLoader源码分析获取类加载器的
反射与注解
wyy的博客
03-31 983
文章目录一、反射二、注解 一、反射 1.1反射引入 • 编译时知道类或对象的具体信息，此时直接对类和对象进行操作即可，无需反射（reflection） • 如果编译不知道类或对象的具体信息，此时应该如何做呢？使用反射来实现。比如类的名称放在XML文件中，属性和属性值放在XML文件中，需要在运行时读取XML文件，动态获取类的信息 • 反射的应用场合 o 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息 o 比如log4j，Servlet、SSM框架技术都用到了反射
注解反射详解
最新发布
小柒的博客
08-17 260
注解反射
java——反射与注解
Why_does_it_work的博客
06-24 6280
我们可以通过Java的元注解来自定义注解。Java的元注解包括@Retention、@Target、@Inherited和@Documented。其中，@Retention用于指定注解的生命周期，@Target用于指定注解可以应用于哪些元素，@Inherited用于指定子类是否继承注解，@Documented用于指定注解是否出现在Java文档中。上述代码定义了一个名为MyAnnotation的注解，它有两个属性：name和age。
反射和注解
lsplook的博客
08-28 179
java.lang.Class 表示类的类型。一个Class类对象就代表了某个类的字节码对象。获取到这个类的字节码对象后该类中所有的内容都会被知道，然后就可以对这个类中的内容进行操作。Class类是Java 反射机制的起源和入口 ，用于获取与类相关的各种信息，提供了获取类信息的相关方法，Class类继承自Object类。java中提供的对反射支持的类都在java.lang.reflet包中。java.lang.reflect.Field 表示类中属性的属性对象。类中每一个属性对应一个属性对象。
进阶Spring必看——注解与反射
Reische的博客
11-03 288
Annotation是从JDK5.0引入的新技术Annotation的作用：不是程序本身，但可以对程序做出解释。（这一点和注释comment没什么区别）可以被其他程序（比如：编译器等）读取。Annotation的格式：注解是以“@注释名”在代码中存在的，还可以添加一定参数值，如Annotation在哪里使用？可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。
注解与反射高效开发法.pdf
05-26
总之，注解与反射是Java语言的核心高级特性之一，它们能够提供强大的代码动态性，对于实现框架设计、简化代码编写等都有极大的帮助。Java开发者应当充分理解和掌握这些高级特性，以便在实际开发中运用自如。
反射操作注解与反射操作泛型.docx
04-16
反射操作注解与反射操作泛型 在 Java 编程中，反射操作和泛型是两个重要的概念。反射操作是指在运行时检查和修改类、对象、方法、字段等信息的能力，而泛型是指在编译时检查和限制类型的能力。本文将详细介绍反射...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
JavaSE-注解与反射(框架底层实现机制)
12-21
JavaSE中的注解（Annotation）和反射（Reflection）是两种非常重要的编程特性，它们在现代Java框架和库的实现中起着至关重要的作用。自从JDK5.0引入注解以来，它已经成为编写更加优雅、可维护代码的一种手段。而反射...
java自定义注解和通过反射获取注解
05-31
自定义注解和通过反射获取注解
写Java 代码
11-03 269
一、编写Java源程序 二、编译Java源代码 三、执行Java源文件 四、JVM如何执行字节码文件 对于任何一门语言，要想达到精通的水平，研究它的执行原理(或者叫底层机制)不失为一种良好的方式。 在本篇文章中，将重点研究java源代码的执行原理，即从程序员编写JAVA源代码，到最终形成产品，在整个过程中，都经历了什么？每一步又是怎么执行的？执行原理又是什么？ （一）装载字节码文件 当 .java...
注解和反射.代码部分
qq_54803395的博客
06-07 118
annotation package com.kuang.annotation; import java.util.ArrayList; import java.util.List; public class Test01 extends Object{ @Override public String toString() { return super.toString(); } //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好
通过反射获取注解（java）
weixin_51395608的博客
07-11 1561
通过反射获取注解，注解使用
Java高级特性：注解与反射深度解析
"注解与反射是Java编程中的高级特性，它们极大地增强了代码的灵活性和可维护性。本文档深入探讨了这两个主题，旨在帮助Java开发者提升技能，尤其是在Android和后端开发领域。" Java注解（Annotation）是自JDK 5.0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值