注解和反射

于 2022-05-05 00:00:00 发布
阅读量189 收藏
点赞数
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cl087616/article/details/124573650
版权

注解

1.注解入门 Annotation

Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记**，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。

注释：comment

Annotation的作用

  • 不是程序本身，可以对程序作出解释。
  • 可以被其他程序（比如编译器）读取

Annotation的格式

  • 注释是以@注释名，在代码中存在的，还可以添加一些参数值，

Annotation在那里使用？

可以附加在package，class，method，filed上面相当于给他们添加了额外的辅助信息，可以通过反射机制实现对这些元数据的访问。

2.内置注解

  1. @Override：定义在java.lang.Override中，此注释只适用于修辞方式，表示一个方法打算重写超类中的另一个方法声明

  2. @Deprecated：定义在java,lang.Deprecated中，此注解可以用于修辞方法，属性，类，不鼓励使用，因为太危险或有更好的选择

  3. @SuppressWarning：定义在java,lang.SuppressWarning中，用来抑制编译的警告信息，

    • 与前两个注解不同，他需要添加一个参数才能正确使用，这些参数都已经定义好了，选择性使用即可

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tTn5Upnr-1651654897159)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700015.jpg)]

笔记

import sun.applet.Main;

import java.util.ArrayList;
import java.util.List;

public class Test01 {
    @Override  //重写的注解，此注释只适用于修辞方法，表示打算重写超类中的另一个方法声明
    public String toString(){
        return super.toString();
    }
//    @Deprecated 不推荐使用，但可以使用，或者存在更好的选择
    @Deprecated
    public static void test(){
        System.out.println("Deprecated");
    }

    @SuppressWarnings("all")//镇压警告功能
    public void test02(){
        List list=new ArrayList();

    }


    public static void main(String[] args) {
        test();
    }
}

3.元注解 meta-annotation

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HxdUj0sx-1651654897160)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700016.png)]

//测试元注解（负责注解其他注解的注解，共有4个@Target，@Retention，@Document，@Inherited） meta-annotation

import java.lang.annotation.*;

public class Test02 {
    @Myannotation//
    public void test(){

    }
}

//定义一个注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})//测试元注解,描述了注解的使用范围，method表示在方法里面，type表示类，多看源码
@Retention(value = RetentionPolicy.RUNTIME)//@Retention元注解表示我们的注解在什么地方还有效，RUNTIME运行时， SOURCE,源码，CLASS，类
//runtime>class>method

//Documented 表示是否将我们的注解生成为在javadoc中
@Documented
//Inherited 表示子类是否可以继承父类的注解
@Inherited
@interface Myannotation{ //我们自己定义的注解

}

4.自定义注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n2TPQJ8A-1651654897161)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700017.png)]

import org.omg.CORBA.PUBLIC_MEMBER;

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

//自定义注解
public class Test03 {
//    注解可以显示赋值，如果没有默认值，就必须给注解赋值
    @Myannotion2(age = 18,id = 2)
    public void test01(){

    }
    @Myannotion3("2")
    public void TEST02(){

    }
}

@Target(value = {ElementType.TYPE,ElementType.METHOD}) //作用范围是类和方法
@Retention(RetentionPolicy.RUNTIME)//作用时间是运行即有效
@interface  Myannotion2{
//    注解的类型：参数类型 +参数名（）；
    String name()default "";
    int age() default 0;
    int id ()default -1;//如果默认为-1，则代表不存在
    String[]school()default {"西北大学","北大"};
}

@Target(value = {ElementType.TYPE,ElementType.METHOD}) //作用范围是类和方法
@Retention(RetentionPolicy.RUNTIME)//作用时间是运行即有效
@interface Myannotion3{
    String value();//当参数名为value时，可以在给注解赋值时省略参数名，直接写
}

反射

1.反射概述reflection

由静态变成动态

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-801jqDGV-1651654897161)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700018.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pGlPq9Xx-1651654897161)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700019.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mHRM7UZA-1651654897162)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700020.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jHBfmw42-1651654897162)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700021.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GPA4ijdB-1651654897162)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700022.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g0HYixH2-1651654897163)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700023.png)]

2.获得反射对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rBTb0Bgm-1651654897163)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700024.png)]

4种方式：（1）forName（2）类.class （3） 对象名.getClass() (4)包装类Type

抛出异常：Ctrl+alt+t，自动匹配变量：alt+enter

// 一个类只有一个Class对象在内存中。
// 一个类被加载后。整个类的的结构都会被封装在Class对象中

package reflection;
//什么叫反射
public class test01 {
//通过反射获取类的class对象
public static void main(String[] args) throws ClassNotFoundException {
    Class c1=Class.forName("reflection.User");//Class是一个类名，forName（包名.类名）
    System.out.println(c1);

//    一个类只有一个Class对象在内存中。
//    一个类被加载后。整个类的的结构都会被封装在Class对象中
    Class c2=Class.forName("reflection.User");
    Class c3=Class.forName("reflection.User");
    Class c4=Class.forName("reflection.User");
    System.out.println(c2.hashCode());//460141958
    System.out.println(c3.hashCode());//   460141958
    System.out.println(c4.hashCode());//    460141958
}
}


//定义一个实体类：pojo,entity
class User{
    private String name;
    private int age;
    private int id;
    //alt+insert

    public User() {
    }

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

    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;
    }

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

3.得到Class类的四种方式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EWQ54Qu3-1651654897164)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700025.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FBb42aX3-1651654897164)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700026.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tGMvx8dD-1651654897164)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700027.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EcRBczJ0-1651654897165)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700028.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R8PI8KHe-1651654897165)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700029.png)]

package reflection;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person=new Student();
        System.out.println("这个人是："+person.name);
//    1.已知具体的类，通过类.class得到
        Class c1 = Student.class;
        System.out.println(c1.hashCode());
//2.已知实例化对象，调用该对象的getClass();
        Class c2 = person.getClass();
        System.out.println(c2.hashCode());
//3.已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forname()得到
        Class C3 = Class.forName("reflection.Student");
        System.out.println(C3.hashCode());

//4.内置基本数据类型可以直接用类名.Type
        Class c4 = Integer.TYPE;
        System.out.println(c4.hashCode());

        //    获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

class Person{
    public String name;

    public Person() {
    }

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

}
class Student extends Person{
    public Student(){
        this.name="学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name="老师";
    }
}

4.所有类型的Class对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GBzjbHz4-1651654897166)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700030.png)]

相同类型的实例对象的Class对象都是同一个

package reflection;

import java.lang.annotation.ElementType;

public class Test03 {
    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);//class java.lang.Object
        System.out.println(c2);//interface java.lang.Comparable
        System.out.println(c3);//class [Ljava.lang.String;
        System.out.println(c4);//class [[I
        System.out.println(c5);//interface java.lang.Override
        System.out.println(c6);//class java.lang.annotation.ElementTyp
        System.out.println(c7);//class java.lang.Integer
        System.out.println(c8);//void
        System.out.println(c9);//class java.lang.Class


    }
}

5.类加载内存分析

JVM前置学习

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1trKJS1S-1651654897166)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700031.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lCJaLHGu-1651654897167)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700032.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5PbBEbIK-1651654897167)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700033.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WnNisAiw-1651654897168)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700035.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gvT3a6C6-1651654897168)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700036.png)]

package reflection;

public class Test04 {
    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=100;
                static int m=88;
    }
 */
    }
}
class A{
    static {
        System.out.println("这是A类静态代码块的初始化");
        m=100;
    }
    static int m=88;
    public A(){
        System.out.println("A的无参构造初始化");
    }
}

6.分析类的初始化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tlzJZ9TD-1651654897168)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700037.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lakh3pzG-1651654897169)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700038.png)]

package reflection;



public class Test05 {
static {
    System.out.println("main类被加载");

}

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        //        Son son=new Son();
        /*
        main类被加载
        父类被加载
        子类被加载
         */

        //2.反射也会主动引用
        //   Class.forName("reflection.Son");

        //不会产生类的引用的方法
//        System.out.println(Son.b);//son并没有被加载
//        Son[] array=new Son[5];//子类和父类都么有加载

        System.out.println(Son.M);
    }
}
class Father{
    static int b=2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m=300;
    }
    static int m=100;
    static final int M=1;
}

7.类加载器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KHUZqS6A-1651654897169)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700039.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J698R7tP-1651654897170)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700040.png)]

获取系统类、扩展类、根加载器

package reflection;

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //2.获取系统类的加载器的父类加载器——>扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //3.获取扩展类加载器的父类加载器——>根加载器（c/c++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

//4.   测试当前类是那个加载器加载的
        ClassLoader classLoader = Class.forName("reflection.Test06").getClassLoader();
        System.out.println(classLoader);

//5.测试JDK内置类是那个加载器加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

//6.如何获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
/*
G:\Environment\java\jre\lib\charsets.jar;
G:\Environment\java\jre\lib\deploy.jar;
G:\Environment\java\jre\lib\ext\access-bridge-64.jar;
G:\Environment\java\jre\lib\ext\cldrdata.jar;
G:\Environment\java\jre\lib\ext\dnsns.jar;
G:\Environment\java\jre\lib\ext\jaccess.jar;
G:\Environment\java\jre\lib\ext\jfxrt.jar;
G:\Environment\java\jre\lib\ext\localedata.jar;
G:\Environment\java\jre\lib\ext\nashorn.jar;
G:\Environment\java\jre\lib\ext\sunec.jar;
G:\Environment\java\jre\lib\ext\sunjce_provider.jar;
G:\Environment\java\jre\lib\ext\sunmscapi.jar;
G:\Environment\java\jre\lib\ext\sunpkcs11.jar;
G:\Environment\java\jre\lib\ext\zipfs.jar;
G:\Environment\java\jre\lib\javaws.jar;
G:\Environment\java\jre\lib\jce.jar;
G:\Environment\java\jre\lib\jfr.jar;
G:\Environment\java\jre\lib\jfxswt.jar;
G:\Environment\java\jre\lib\jsse.jar;
G:\Environment\java\jre\lib\management-agent.jar;
G:\Environment\java\jre\lib\plugin.jar;
G:\Environment\java\jre\lib\resources.jar;
G:\Environment\java\jre\lib\rt.jar;
G:\computerscience\kuangStudyCode\注解和反射\out\production\code_annotation;
G:\Environment\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar

 */
    }
}

8.获取类运行时结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R5YPc7Ky-1651654897170)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700041.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BgIpHcrF-1651654897171)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700042.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SyNFZDgj-1651654897171)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700043.png)]

package reflection;

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

//获得类的信息
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        //1.得到类对象
        Class c1 = Class.forName("reflection.User");
        //Class c2 = User.class;//方法2

         //2.获得类的名字
        String name = c1.getName(); //得到包名+类名
        System.out.println(name);

        String simpleName = c1.getSimpleName();
        System.out.println(simpleName);//得到简单的类名

        //3.获得类的属性
        System.out.println("===========================================");
        Field[] fields = c1.getFields();//只能找的公共的所有属性
//        for (Field field : fields) {
//            System.out.println(field);
//        }//空
       fields=c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("===========================================");
        //4.获得指定类的属性
        //System.out.println( c1.getField("name"));//只能找的公共的单个属性,
        Field name1 = c1.getDeclaredField("name");
        System.out.println(name1);

    //5.获得类的方法
    System.out.println("===========================================");
        Method[] methods = c1.getMethods();//getMethods：获得本类及父类的全部public方法
        for (Method method : methods) {
            System.out.println("公共的"+method);
        }
        methods=c1.getDeclaredMethods();//getDeclaredMethods：获得本类的所有方法
        for (Method method : methods) {
            System.out.println("私有的方法"+method);
        }
    //6.获得指定方法
            //重载
        System.out.println("");
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        //7.获得所有的构造器
        System.out.println("===========================================");
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("");
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        //8.获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);//参数也需要以反射模式输入
        System.out.println("指定+"+declaredConstructor);


    }

}

小结：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JWjzJu6n-1651654897172)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700044.png)]

9.动态创建对象执行方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wg1SShyz-1651654897172)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700045.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qcoiXQnG-1651654897173)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700046.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AFul9XDn-1651654897173)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700047.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tz7iyx3J-1651654897174)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700048.png)]

package reflection;

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

//动态的创建对象，通过反射
public class Test08 {
    public static void main(String[] args) throws Exception {
        //1.获取对象
        Class c1 = Class.forName("reflection.User");
        System.out.println(c1);
        //2.构造一个对象
        Object c2 = c1.newInstance();//通过无参的构造方法直接创建了实例化对象  User{name='null', age=0, id=0}
        System.out.println(c2);
/*
如果一个类没有无参构造方法，可以通过反射创建实例吗？
结果是可以的
*/
        //3.通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        Object c3 = declaredConstructor.newInstance("cl", 001, 18);
        System.out.println(c3);

        //4.通过反射调用普通方法
        Object c4 = c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
//innoke:激活的意思
//invoke（obj，”value“)/（对象，”方法的值“）
        setName.invoke(c4,"user4");
        System.out.println(c4);


        //5.通过反射操作属性
        Object c5 = c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //不能直接操作私有属性，需要关闭安全检测，属性、方法都可以用setAccessible
        name.setAccessible(true);//
        name.set(c5,"user5");
        System.out.println(c5);
    }
}

10.性能对比分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F7yBxDIM-1651654897174)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700049.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hS7bEHry-1651654897175)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700050.png)]

11.获取泛型对象信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hY8SJIkG-1651654897175)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700051.png)]

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;

//通过反射操作泛型
public class Test09 {
    public static void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }

    public static Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }
    public static void main(String[] args) throws Exception {
        //1.获得反射对象
        Class<Test09> class01 = Test09.class;
        //2.通过反射操作方法
        Method method01 = class01.getMethod("test01", Map.class, List.class);
        //3.通过反射得到的方法来得到参数化泛型
        Type[] genericParameterTypes = method01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("!!!" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }


        Method method2 = Test09.class.getMethod("test02", null);
        Type genericReturnType = method2.getGenericReturnType();

        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }


        }
    }}

12.获取注解信息

package reflection;

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

public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
//        1.通过反射获得反射对象
        Class<?> c1 = Class.forName("reflection.student02");
        //2.通过反射获得注解对象
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);//@reflection.tableannotion(value=kuang)

        }
        //3.获取注解value的值
        tableannotion tableannotion = c1.getAnnotation(tableannotion.class);
        String value = tableannotion.value();
        System.out.println(value);

        //4.获得类指定字段的注解
        Field name = c1.getDeclaredField("name");
        fieldannotion annotation = name.getAnnotation(fieldannotion.class);

        
        System.out.println(annotation.columnName());
    }
}

@tableannotion("kuang")
class student02{
    @fieldannotion(columnName = "db_id",type = "int",length = 10)
    private int id;
    @fieldannotion(columnName = "db_age",type = "int",length = 10)
    private int age;
    @fieldannotion(columnName = "db_name",type = "varchar",length =3)
    private String name;

    public student02() {
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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


//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface tableannotion{
    String value();
}

//属性的注解
@interface fieldannotion{
    String columnName()default "ss";//列名
    String type() default "wa";//类型
    int length() default 0;//长度
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oFZkpMK3-1651654897176)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700052.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JlMjVpWF-1651654897176)(r9ptik78f.hn-bkt.clouddn.com/img/blog202205041700053.png)]
= id;
}

public int getAge() {
    return age;
}

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

public String getName() {
    return name;
}

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

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

}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface tableannotion{
String value();
}

//属性的注解
@interface fieldannotion{
String columnName()default “ss”;//列名
String type() default “wa”;//类型
int length() default 0;//长度
}


[外链图片转存中...(img-oFZkpMK3-1651654897176)]

[外链图片转存中...(img-JlMjVpWF-1651654897176)]
奥丁之眼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1201
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2377
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
注解和反射机制的学习笔记
03-05
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的工具，它们极大地扩展了代码的灵活性和动态性。这篇学习笔记将深入探讨这两个主题，帮助开发者更好地理解和运用它们。 首先，我们来了解注解...
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
Java使用注解和反射简化编程的方法示例
08-25
例如，在调用大量方法时，可以使用反射和注解简化编程。 下面是一个使用注解和反射简化编程的实例。首先，定义一个注解testAnnoation10： ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target...
Java中关于注解和反射机制的内容
11-04
Java中关于注解和反射机制的内容
Java基础篇之注解和反射
01-06
Java基础注解和反射入门思维导图 毕竟在SpringBoot以及之后使用的基本全是注解很少用配置文件 反射是必须要会的
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
根据提供的文件信息，我们可以梳理出以下知识点： ...以上知识点详细阐述了文档中提到的方法和技术原理，为理解和应用Java注解和反射机制在Excel文件读写操作中的实际应用提供了理论基础和技术指导。
Java基础-注解和反射
09-11
### Java基础-注解和反射 #### 注解(Annotation) 从JDK5开始，Java引入了一个重要的特性——元数据支持，即注解。这是一项强大的功能，它允许开发者在不改变原有代码逻辑的情况下向源代码中添加额外的信息。注解在...
JAVA 注解和反射.7z
04-08
总结，Java注解和反射是Java开发中非常重要的技术，它们极大地增强了Java的灵活性和可扩展性。注解简化了代码，提供了元数据，而反射则允许程序在运行时探索和修改自身的结构，两者共同推动了Java的广泛应用。了解并...
注解+ 反射实例demo
11-29
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的特性，它们极大地扩展了代码的可读性和动态性。注解是一种元数据，可以为编译器、工具或运行时系统提供信息，而反射则允许程序在运行时检查类...
java基础知识学习教程-12注解和反射.pptx
最新发布
10-30
11. 案例：三酷猫的注解反射对比小程序 本节提供了一个案例，演示了如何使用注解和反射机制来实现一个小程序。 12. 练习和实验 本节提供了一些练习和实验题目，旨在帮助读者更好地理解和掌握注解和反射机制的知识点...
java基础的注解和反射的相关知识点总结
09-06
Java中的注解（Annotation）和反射（Reflection）是两种强大的工具，它们提供了程序设计的灵活性和动态性。本文将深入探讨这两个概念及其相关知识点。 **注解** 是一种元数据，它提供了在代码中附加信息的方式，...
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奥丁之眼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值